import GHC.Types.SrcLoc

 import GHC.Types.Tickish (CoreTickish)

 import GHC.Types.Unique.Set (UniqSet)

 import GHC.Core.ConLike ( conLikeName, ConLike )

 import GHC.Unit.Module (ModuleName)

 import GHC.Utils.Misc

 import Data.List.NonEmpty (NonEmpty (..))

 import qualified Data.List.NonEmpty as NE

 import Data.Void (Void)

 {- *********************************************************************

 *                                                                      *

                 Expressions proper

   deriving Data

 -- | Pending Renamer Splice

 data PendingRnSplice

   = PendingRnSplice UntypedSpliceFlavour SplicePointName (LHsExpr GhcRn)

 -- | Pending Type-checker Splice

 data PendingTcSplice

 instance Outputable PendingRnSplice where

   ppr (PendingRnSplice _ n e) = pprPendingSplice n e

 instance Outputable PendingTcSplice where

   ppr (PendingTcSplice n e) = pprPendingSplice n e

 instance ToHie PendingRnSplice where

   toHie (PendingRnSplice _ _ e) = toHie e

 instance ToHie PendingTcSplice where

   toHie (PendingTcSplice _ e) = toHie e

             -- matching GRE and add a name clash error

             -- (see lookupGlobalOccRn_overloaded, called by lookupExprOccRn).

             -> do { let sel_name = flSelector $ recFieldLabel fld_info

                   ; return (XExpr (HsRecSelRn (FieldOcc v  (L l sel_name))), unitFV sel_name)

                   }

             | nm == nilDataConName

             -> rnExpr (ExplicitList noAnn [])

             | otherwise

         }}}

 import GHC.Utils.Logger

 import GHC.Utils.Panic

 import GHC.Driver.Hooks

                             , patQTyConName, quoteDecName, quoteExpName

                             , quotePatName, quoteTypeName, typeQTyConName)

 rn_utbracket :: HsQuote GhcPs -> RnM (HsQuote GhcRn, FreeVars)

 rn_utbracket (VarBr _ flg rdr_name)

   = do { name <- lookupOccRn (if flg then WL_Term else WL_Type) (unLoc rdr_name)

        ; check_namespace flg name

        ; return (VarBr noExtField flg (noLocA name), unitFV name) }

 rnUntypedSplice (HsQuasiQuote ext quoter quote)

   = do  { -- Rename the quoter; akin to the HsVar case of rnExpr

         ; quoter' <- lookupOccRn WL_TermVariable quoter

         ; this_mod <- getModule

         ; when (nameIsLocalOrFrom this_mod quoter') $

         ; return (HsQuasiQuote ext quoter' quote, unitFV quoter') }

 -- | Check whether we are allowed to use a Name in this context (for TH purposes)

 -- In the case of a level incorrect program, attempt to fix it by using

 -- a Lift constraint.

 checkThLocalNameWithLift = checkThLocalName True

 -- | Check whether we are allowed to use a Name in this context (for TH purposes)

 -- In the case of a level incorrect program, do not attempt to fix it by using

 -- a Lift constraint.

 checkThLocalNameNoLift = checkThLocalName False

   | isUnboundName name   -- Do not report two errors for

   = return ()            --   $(not_in_scope args)

         ; dflags <- getDynFlags

         ; env <- getGlobalRdrEnv

         ; let mgre = lookupGRE_Name env name

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

 checkCrossLevelLifting :: DynFlags

                        -> Set.Set ThLevelIndex

                        -> ThLevel

                        -> ThLevelIndex

   -- 1. If name is in-scope, at the correct level.

   | use_lvl_idx `Set.member` bind_lvl = return ()

   -- 2. Name is imported with -XImplicitStagePersistence

   , any (use_lvl_idx >=) (Set.toList bind_lvl)

   , allow_lifting

   = do

   -- 5. For a typed bracket, these checks happen again later on (checkThLocalId)

   -- In the future we should do all the level checks here.

   | Brack _ RnPendingTyped <- use_lvl  -- Lift for typed brackets is inserted later.

   , any (use_lvl_idx >=) (Set.toList bind_lvl)

     = return ()

   -- Otherwise, we have a level error, report.

 checkCrossLevelLiftingTy :: DynFlags -> TopLevelFlag -> Set.Set ThLevelIndex -> ThLevel -> ThLevelIndex -> Name -> TcM ()

 checkCrossLevelLiftingTy dflags top_lvl bind_lvl _use_lvl use_lvl_idx name

     report1 = [ ("custom_error", is_user_type_error, True,  mkUserTypeErrorReporter)

                  -- (Handles TypeError and Unsatisfiable)

               , given_eq_spec

               , ("insoluble2",      utterly_wrong,  True, mkGroupReporter mkEqErr)

               , ("skolem eq1",      very_wrong,     True, mkSkolReporter)

     -- See also Note [Implementation of Unsatisfiable constraints], point (F).

     is_user_type_error item _ = containsUserTypeError (errorItemPred item)

     is_homo_equality _ (EqPred _ ty1 ty2)

       = typeKind ty1 `tcEqType` typeKind ty2

     is_homo_equality _ _

 mkUserTypeErrorReporter ctxt

   = mapM_ $ \item -> do { let err = important ctxt $ mkUserTypeError item

                         ; maybeReportError ctxt (item :| []) err

 mkUserTypeError :: ErrorItem -> TcSolverReportMsg

 mkUserTypeError item

   where

     pty = errorItemPred item

 mkGivenErrorReporter :: Reporter

 -- See Note [Given errors]

 mkGivenErrorReporter ctxt (item:|_)

        ; maybeReportError ctxt items err

            -- But see Note [Always warn with -fdefer-type-errors]

        ; traceTc "reportGroup" (ppr items)

            -- Add deferred bindings for all

            -- Redundant if we are going to abort compilation,

            -- but that's hard to know for sure, and if we don't

        msg <- mkErrorReport (ctLocEnv (errorItemCtLoc item1)) diag (Just ctxt) supp hints

        reportDiagnostic msg

 -- See Note [Deferring coercion errors to runtime]

   -- if evdest is Just, then the constraint was from a wanted

        ; let ev_binds_var = cec_binds ctxt

        ; case dest of

                      let co_var = coHoleCoVar hole

                    ; addTcEvBind ev_binds_var $ mkWantedEvBind co_var EvNonCanonical err_tm

                    ; fillCoercionHole hole (mkCoVarCo co_var) } }

 mkErrorTerm :: CtLoc -> Type  -- of the error term

   = do { msg <- mkErrorReport

                   (ctLocEnv ct_loc)

                   supp

                   hints

          -- This will be reported at runtime, so we always want "error:" in the report, never "warning:"

       -- not for holes in partial type signatures

       -- cf. addDeferredBinding

       when (deferringAnyBindings ctxt) $ do

           -- NB: ref_ty, not hole_ty. hole_ty might be rewritten.

           -- See Note [Holes in expressions] in GHC.Hs.Expr

         writeMutVar ref err_tm

 import GHC.Types.Var.Set

 import GHC.Types.Var.Env

 import GHC.Types.Fixity (defaultFixity)

 import GHC.Iface.Errors.Types

 import GHC.Iface.Errors.Ppr

       hsep [ text "Unknown type variable" <> plural errorVars

            , text "on the RHS of injectivity condition:"

            , interpp'SP errorVars ]

     TcRnBadlyLevelledType name bind_lvls use_lvl

       -> mkSimpleDecorated $

          text "Badly levelled type:" <+> ppr name <+>

       -> ErrorWithoutFlag

     TcRnUnknownTyVarsOnRhsOfInjCond{}

       -> ErrorWithoutFlag

     TcRnBadlyLevelledType{}

       -> WarningWithFlag Opt_WarnBadlyLevelledTypes

     TcRnTyThingUsedWrong{}

   diagnosticCode = constructorCode @GHC

 note :: SDoc -> SDoc

 note note = "Note" <> colon <+> note <> dot

               : pp_givens useful_givens)

     supplementary = case mb_extra of

       Just (CND_Extra level ty1 ty2)

         -> mk_supplementary_ea_msg ctxt level ty1 ty2 orig

     ct_loc = errorItemCtLoc item

       text "in" <+> quotes (ppr req_uid) <> dot

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

     :: !LevelCheckReason -- ^ The binding

     -> !(Set.Set ThLevelIndex) -- ^ The binding levels

     -> !ThLevelIndex -- ^ The level at which the binding is used.

     -> TcRnMessage

   {-| TcRnBadlyLevelledWarn is a warning that occurs when a TH type binding is

 import GHC.Tc.Utils.Monad

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Gen.Expr

 import GHC.Tc.Utils.Unify

 import GHC.Tc.Utils.Env

 import GHC.Tc.Types.Origin

        -- Match the expected type with the type of all the internal

        -- splices. They might have further constrained types and if they do

        -- we want to reflect that in the overall type of the bracket.

                   Nothing -> assert (null ps) $ return []

        -- Notice that we don't attempt to typecheck the body

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

 -- | Typechecking a pending splice from a untyped bracket

                           -- quotation.

                 -> PendingRnSplice

                 -> TcM PendingTcSplice

   -- See Note [Typechecking Overloaded Quotes]

   = do { meta_ty <- tcMetaTy meta_ty_name

          -- Expected type of splice, e.g. m Exp

                        UntypedPatSplice  -> patTyConName

                        UntypedTypeSplice -> typeTyConName

                        UntypedDeclSplice -> decsTyConName

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

 -- Takes a m and tau and returns the type m (TExp tau)

   -- With ImplicitStagePersistence, using later than bound is fine

   | xopt LangExt.ImplicitStagePersistence dflags

   , any (use_lvl_idx >=) bind_lvls  = return ()

 import GHC.Utils.Misc( HasDebugCallStack )

 import GHC.Types.Unique

 import GHC.Types.Unique.Supply

 import Language.Haskell.Syntax.Basic (FieldLabelString(..))

 import qualified Data.Kind as Hs

 import Data.List.NonEmpty (NonEmpty (..))

 {- *********************************************************************

 *                                                                      *

       Type   -- the instance-sig type

       Type   -- the instantiated type of the method

   | AmbiguityCheckOrigin UserTypeCtxt

 data NonLinearPatternReason

   = LazyPatternReason

 pprCtO (OmittedFieldOrigin Nothing) = text "an omitted anonymous field"

 pprCtO (OmittedFieldOrigin (Just fl)) = hsep [text "omitted field" <+> quotes (ppr fl)]

 pprCtO BracketOrigin         = text "a quotation bracket"

 -- These ones are handled by pprCtOrigin, but we nevertheless sometimes

 -- get here via callStackOriginFS, when doing ambiguity checks

 pprNonLinearPatternReason ViewPatternReason = parens (text "view patterns aren't linear")

 pprNonLinearPatternReason OtherPatternReason = empty

 {- *********************************************************************

 *                                                                      *

              CallStacks and CtOrigin

 import GHC.Prelude

 import GHC.Utils.Outputable

 import GHC.Types.Basic ( ImportLevel(..) )

 -- | The integer which represents the level

     -- NB: see Note [Template Haskell levels] in GHC.Tc.Gen.Splice

     -- Incremented when going inside a bracket,

     -- decremented when going inside a splice

 thLevelIndexFromImportLevel :: ImportLevel -> ThLevelIndex

 thLevelIndexFromImportLevel NormalLevel = topLevelIndex

 thLevelIndexFromImportLevel SpliceLevel = spliceLevelIndex

 test('T21619', normal, compile, [''])

 test('T20472_quotes', normal, compile, [''])

 test('T24750', normal, compile_and_run, [''])

 TH_Lift.hs:18:6-39: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Integer)

   ======>

     5

 TH_Lift.hs:21:6-35: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Int)

   ======>

     5

 TH_Lift.hs:24:7-37: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Int8)

   ======>

     5

 TH_Lift.hs:27:7-38: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Int16)

   ======>

     5

 TH_Lift.hs:30:7-38: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Int32)

   ======>

     5

 TH_Lift.hs:33:7-38: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Int64)

   ======>

     5

 TH_Lift.hs:36:6-36: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Word)

   ======>

     5

 TH_Lift.hs:39:6-37: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Word8)

   ======>

     5

 TH_Lift.hs:42:6-38: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Word16)

   ======>

     5

 TH_Lift.hs:45:6-38: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Word32)

   ======>

     5

 TH_Lift.hs:48:6-38: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Word64)

   ======>

     5

 TH_Lift.hs:51:7-40: Splicing expression

     (\ x

        -> [| x |]

       (5 :: Natural)

   ======>

     5

 TH_Lift.hs:54:6-44: Splicing expression

     (\ x

        -> [| x |]

       (5 % 3 :: Rational)

   ======>

     1.6666666666666667

 TH_Lift.hs:57:7-39: Splicing expression

     (\ x

        -> [| x |]

       (pi :: Float)

   ======>

     3.1415927410125732

 TH_Lift.hs:60:7-40: Splicing expression

     (\ x

        -> [| x |]

       (pi :: Double)

   ======>

     3.141592653589793

 TH_Lift.hs:63:6-28: Splicing expression

     (\ x

        -> [| x |]

       'x'

   ======>

     'x'

 TH_Lift.hs:66:6-29: Splicing expression

     (\ x

        -> [| x |]

       True

   ======>

     True

 TH_Lift.hs:69:6-35: Splicing expression

     (\ x

        -> [| x |]

       (Just 'x')

   ======>

     Just 'x'

 TH_Lift.hs:72:6-58: Splicing expression

     (\ x

        -> [| x |]

       (Right False :: Either Char Bool)

   ======>

     Right False

 TH_Lift.hs:75:6-29: Splicing expression

     (\ x

        -> [| x |]