type instance XCase          GhcTc = HsMatchContextRn

 type instance XIf            GhcPs = AnnsIf

 type instance XIf            GhcTc = NoExtField

 type instance XMultiIf       GhcPs = (EpToken "if", EpToken "{", EpToken "}")

 type instance XDo            GhcTc = Type

 type instance XExplicitList  GhcPs = AnnList ()

 type instance XExplicitList  GhcTc = Type

 -- GhcPs: ExplicitList includes all source-level

 --   list literals, including overloaded ones

 type instance XRecordCon     GhcTc = PostTcExpr   -- Instantiated constructor function

 type instance XRecordUpd     GhcPs = (Maybe (EpToken "{"), Maybe (EpToken "}"))

 type instance XRecordUpd     GhcTc = DataConCantHappen

   -- We desugar record updates in the typechecker.

   -- See [Handling overloaded and rebindable constructs],

 type CmdSyntaxTable p = [(Name, HsExpr p)]

 -- See Note [CmdSyntaxTable]

 -- Stores the names of the operators for rebindable syntax

 -- eg. getField, setField etc.

 -- GHC.Tc.Expand will use these names to build the expansions

 {-

 Note [CmdSyntaxTable]

 ~~~~~~~~~~~~~~~~~~~~~

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

 -- Data derivations from GHC.Hs.Expr -----------------------------------

 deriving instance Data (FieldLabelStrings GhcPs)

 deriving instance Data (FieldLabelStrings GhcRn)

 deriving instance Data (FieldLabelStrings GhcTc)

 deriving instance Data a => Data (WithUserRdr a)

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

 deriving instance Data XXExprGhcTc

 deriving instance Data XXPatGhcTc

 import GHC.Tc.Types.ErrCtxt

 import GHC.Tc.TyCl ( IsPrefixConGADT(..), unannotatedMultIsLinear )

 import GHC.Core.Class

 import GHC.Core.DataCon

 import GHC.Core.TyCon

                                ; ms2 <- mapM repMatchTup ms

                                ; core_ms2 <- coreListM matchTyConName ms2

                                ; repCaseE arg core_ms2 }

 repE (HsMultiIf _ alts)

   = do { (binds, alts') <- NE.unzip <$> mapM repLGRHS alts

        ; expr' <- repMultiIf (nonEmptyCoreList' alts')

 -- HsOverLabel: see Note [Handling overloaded and rebindable constructs]

 rnExpr (HsOverLabel src v)

   = do { (from_label, fvs) <- lookupSyntaxName fromLabelClassOpName

        ; return (HsOverLabel (src, rs_table) v, fvs)

        }

  = do { (getField, fv_getField) <- lookupSyntaxName getFieldName

       ; (e, fv_e) <- rnLExpr e

       ; let f' = rnDotFieldOcc <$> f

       ; return (HsGetField rs_table e f', fv_e `plusFN` fv_getField) }

 rnExpr (HsProjection _ fs)

   = do { (getFieldName, fv_getField) <- lookupSyntaxName getFieldName

        ; circName <- lookupOccRn WL_TermVariable compose_RDR

        ; let fs' = NE.map rnDotFieldOcc fs

        ; return (HsProjection rs_table fs', unitFN circName `plusFN` fv_getField) }

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

   = do  { (exps', fvs) <- rnExprs exps

         ; opt_OverloadedLists <- xoptM LangExt.OverloadedLists

         ; if not opt_OverloadedLists

           else

     do { (from_list_n_name, fvs') <- lookupSyntaxName fromListNName

              rn_list  = ExplicitList rs_table exps'

        ; return ( rn_list

                 , fvs `plusFN` fvs') } }

                     RegularRecUpdFields

                     { xRecUpdFields = parents

                     , recUpdFields  = flds }

                      , fv_e `plusFN` fv_flds ) }

       -- 'OverloadedRecordUpdate' is in effect. Record dot update desugaring.

            ; let upd_flds = OverloadedRecUpdFields

                             { xOLRecUpdFields = noExtField

                             , olRecUpdFields  = us }

            ; return (RecordUpd rs_table (L l e) upd_flds

                     , plusFNs [fv_getField, fv_setField, fv_e, fv_us] )

            }

        ; mb_ite <- lookupIfThenElse

        ; case mb_ite of

             Nothing  -- Non rebindable-syntax case

             Just ite_name   -- Rebindable-syntax case

               -> do { let fvs   = plusFNs [fvs_if, unitFN ite_name]

 rnHsUpdProjs :: [LHsRecUpdProj GhcPs] -> RnM ([LHsRecUpdProj GhcRn], FreeNames)

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

 -}

 import GHC.Prelude hiding (last, init, tail)

 import GHC.Hs

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Types.ErrCtxt

 import GHC.Tc.Gen.Do

 import GHC.Types.Name

 import GHC.Types.Id.Make

 import GHC.Types.SrcLoc

 import GHC.Types.SourceText ( mkIntegralLit , SourceText(..) )

 import GHC.Rename.Utils

 import GHC.Utils.Panic

 import GHC.Utils.Outputable

 import qualified GHC.LanguageExtensions as LangExt

 {- Note [Typechecking by expansion: overview]

 -- See Note [Typechecking by expansion: overview]

 tcExpand :: HsExpr GhcRn -> TcM (Maybe (HsExpansion GhcRn))

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

 -- Overloaded labels

   , let hs_ty_arg = mkEmptyWildCardBndrs $ wrapGenSpan $

                       HsTyLit noExtField (HsString NoSourceText v)

     HSE { hse_ctxt = ExprCtxt e

         , hse_exp = wrapGenSpan $ HsAppType noExtField (genLHsVar fromLabelName) hs_ty_arg

         }

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

 -- Qualified Literals

   = do { let hsLit = case ql_val of

                         -- See Note [Implementation of QualifiedStrings]

                         HsQualString st s -> HsString st s

        }

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

 -- Operator Applications

     HSE { hse_ctxt = ExprCtxt e

         , hse_exp  = foldl ap op [arg1,arg2] }

   where

     ap f a = wrapGenSpan (HsApp noExtField f a)

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

 -- Left and Right Sections

           HSE { hse_ctxt = ExprCtxt e

               , hse_exp = wrapGenSpan ds_section } }

   = return Nothing -- rebindable syntax is off

   = do { loc <- getSrcSpanM -- See Note [Source locations for implicit function calls]

        ; let lit_n    = mkIntegralLit (length exps)

              hs_lit   = genHsIntegralLit lit_n

              exp_list = genHsApps' (wrapGenSpan' loc from_list_n_name)

        ; return $ Just $

          HSE { hse_ctxt = ExprCtxt e

              , hse_exp = wrapGenSpan $ exp_list }

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

 tcExpand (HsDo _ do_or_lc stmts)

   | DoExpr{} <- do_or_lc

   -- GHCiStmts are handled completely separate

   = return Nothing

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

 -- Template Haskell Splices

 -- See Note [Looking through Template Haskell splices in splitHsApps]

   = do { fun <- getUntypedSpliceBody splice_res

        ; return $ Just $

 -- list type, so that's all we need concern ourselves with here.  See

 -- GHC.Rename.Expr. Note [Handling overloaded and rebindable constructs]

 tcExprNoExpand (ExplicitList x exprs) res_ty

     do  { res_ty <- expTypeToType res_ty

         ; (coi, elt_ty) <- matchExpectedListTy res_ty

         ; let tc_elt expr = tcCheckPolyExpr expr elt_ty

 tcExprNoExpand (HsIf x pred b1 b2) res_ty

   -- HsIf in rebindable case would be expanded out so we would not

   -- have a Just RebindableSyntaxTable here, only Nothing

     do { pred'    <- tcCheckMonoExpr pred boolTy

        ; let res_ty' = adjustExpTypeForCaseBranches res_ty [b1,b2]

        ; (u1,b1') <- tcCollectingUsage $ tcMonoLExpr b1 res_ty'

     orig = OccurrenceOf con_name

 -- Record updates via dot syntax are replaced by expanded expressions

 -- GHC.Hs.Expr. This is why we match on 'rupd_flds = Left rbnds' here

 -- and panic otherwise.

 -- WIP: To be fixed soon (#27160) expandRecordUpd needs to return HsExpansion and not a separate ds_res_ty

                              RegularRecUpdFields

                               { xRecUpdFields = parents

                               , recUpdFields  = rbnds }

         loc  = getLocA (head rbnds)

 {-

     go1 (ParPat _ pat) = fmap (HsPar noExtField) (go pat)

     go1 (ListPat _ pats)

       = do { exprs <- mapM go pats

     go1 (TuplePat _ pats box)       = do { exprs <- mapM go pats

                                          ; return $ ExplicitTuple noExtField

                                            (map (Present noExtField) exprs) box }