import GHC.Tc.Types.Constraint

 import GHC.Tc.Types.CtLoc

 import GHC.Tc.Utils.TcMType

 import GHC.Tc.Zonk.Type

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Zonk.TcType

 import GHC.Tc.Types.Origin

 import GHC.Tc.Types.Evidence

 import GHC.Tc.Instance.Family

 import {-# SOURCE #-} GHC.Tc.Errors.Hole ( findValidHoleFits, getHoleFitDispConfig )

 import GHC.Types.Name

 import GHC.Core.ConLike (isExistentialRecordField, ConLike (..))

 import GHC.Core.Coercion

 import GHC.Core.DataCon

 import GHC.Core.TyCo.Ppr  ( pprTyVars )

 import GHC.Core.TyCo.Tidy

 import GHC.Core.InstEnv

 import GHC.Core.TyCon

 import GHC.Utils.Misc

 import GHC.Utils.Outputable as O

 import GHC.Utils.Panic

                                            , ei_loc = loc })

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

   | deferringAnyBindings ctxt

        ; let ev_binds_var = cec_binds ctxt

        ; case dest of

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

                   -> SolverReport -> TcM EvTerm

 mkSolverErrorTerm ct_loc ty err

   = do { msg <- mkErrorReport

                   (ctLocEnv ct_loc)

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

 tryReporters :: SolverReportErrCtxt -> [ReporterSpec] -> [ErrorItem] -> TcM (SolverReportErrCtxt, [ErrorItem])

 -- Use the first reporter in the list whose predicate says True

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

 -- | Constructs a new hole error, unless this is deferred. See Note [Constructing Hole Errors].

 mkHoleError :: NameEnv Type -> [ErrorItem] -> SolverReportErrCtxt -> Hole -> TcM (MsgEnvelope TcRnMessage)

 mkHoleError _ _tidy_simples ctxt hole@(Hole { hole_sort = sort, hole_occ = occ, hole_loc = ct_loc })

   | isOutOfScopeHole hole

   = do { (imp_errs, hints)

        ; show_hole_constraints <- goptM Opt_ShowHoleConstraints

        ; let relevant_cts

                = givenConstraints ctxt

                | otherwise

                = []

                               then validHoleFits ctxt tidy_simples hole

                               else return (ctxt, noValidHoleFits)

        ; (grouped_skvs, other_tvs) <- liftZonkM $ zonkAndGroupSkolTvs hole_ty

              err  = SolverReportWithCtxt ctxt

                   $ ReportHoleError hole

                   $ HoleError sort other_tvs grouped_skvs

                          -> TcM ()

 maybeAddDeferredBindings hole report = do

   case hole_sort hole of

       -- Only add bindings for holes in expressions

       -- not for holes in partial type signatures

       -- cf. addDeferredBinding

                   -- the hole.

                   -> Hole

                   -> TcM (TidyEnv, ValidHoleFits)

                                                    , hole_loc  = ct_loc

                                                    , hole_ty   = hole_ty }) =

   do { rdr_env <- getGlobalRdrEnv

   , TcRnMessageOpts(..)

   , pprTyThingUsedWrong

   , pprUntouchableVariable

   --

   , mismatchMsg_ExpectedActuals

 import GHC.Utils.Misc

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 import qualified GHC.LanguageExtensions as LangExt

       -> mkSimpleDecorated $

            vcat [ text "The literal" <+> quotes (ppr lit) <+> text "cannot be promoted."

                 , text "It is of the unpromotable type" <+> quotes (ppr (hsLitType lit)) <> dot ]

       -> mkSimpleDecorated $

            if simple_msg

            then

       -> ErrorWithoutFlag

     TcRnUnpromotableLit{}

       -> ErrorWithoutFlag

     TcRnMatchesHaveDiffNumArgs{}

       -> ErrorWithoutFlag

     TcRnCannotBindScopedTyVarInPatSig{}

         , nest 2 $ text "bound by" <+> ppr skol_info

         , nest 2 $ text "at" <+> ppr (getCtLocEnvLoc env) ]

 -- | Which invisible bits of types should be displayed to the user when

 -- rendering a 'MismatchMsg'?

 --

   TcRnIllegalTermLevelUse

     :: !Bool -- ^ should we give a simple "out of scope" message,

              -- instead of a full-blown "Illegal term level use" message?

     -> !RdrName -- ^ the user-written identifier

     -> !Name    -- ^ the type-level 'Name' we resolved it to

     -> !TermLevelUseErr

     -> TcRnMessage

   {-| TcRnMatchesHaveDiffNumArgs is an error occurring when something has matches

   --

   -- Test cases: T9177a.

   = OutOfScopeHole

   -- | Report a typed hole, or wildcard, with additional information.

   | HoleError HoleSort

               [TcTyVar]                     -- Other type variables which get computed on the way.

 import GHC.Tc.Utils.Env

 import GHC.Tc.Types.Origin

 import GHC.Tc.Types.Evidence

 import GHC.Tc.Errors.Types hiding (HoleError)

 import GHC.Core.Multiplicity

 -- Others might simply be variables that accidentally have no binding site.

 tcExpr (HsHole (HoleVar locc@(L _ occ))) res_ty

   = do { ty <- expTypeToType res_ty    -- Allow Int# etc (#12531)

        ; return (HsHole (HoleVar locc, her))

        }

 tcExpr (HsHole HoleError) _ =

 import GHC.Tc.Utils.Instantiate

 import GHC.Tc.Instance.Family ( tcLookupDataFamInst )

 import GHC.Tc.Errors.Types

 import GHC.Tc.Solver          ( InferMode(..), simplifyInfer )

 import GHC.Tc.Utils.Env

 import GHC.Tc.Utils.TcMType

 import GHC.Tc.Types.Origin

 import GHC.Tc.Utils.TcType as TcType

 import GHC.Tc.Types.Evidence

 import GHC.Tc.Zonk.TcType

 import GHC.Builtin.Names

 import GHC.Driver.DynFlags

 import GHC.Utils.Misc

 import GHC.Utils.Outputable as Outputable

 import GHC.Utils.Panic

   = tc_infer_id lname

 tc_infer_id :: LocatedN (WithUserRdr Name) -> TcM (HsExpr GhcTc, TcSigmaType)

  = do { thing <- tcLookup id_name

       ; (expr,ty) <- case thing of

              ATcId { tct_id = id }

              AGlobal (AConLike cl) -> tcInferConLike cl

              _ -> failWithTc $ TcRnExpectedValueId thing

   where

     return_id id = return (mkHsVar (L loc id), idType id)

 {- Note [Overview of assertions]

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

         -- Holes

         Hole(..), HoleSort(..), isOutOfScopeHole,

         DelayedError(..), NotConcreteError(..),

         WantedConstraints(..), insolubleWC, emptyWC, isEmptyWC,

            -- might get reported to the user if reducing type families in a

            -- hole type loops.

 -- | Used to indicate which sort of hole we have.

                  -- ^ Either an out-of-scope variable or a "true" hole in an

                  -- expression (TypedHoles).

                  -- The HoleExprRef says where to write the

                  -- Note [Do not simplify ConstraintHoles] in GHC.Tc.Solver.

 instance Outputable Hole where

             , hole_occ  = occ

             , hole_ty   = ty })

     = parens $ (braces $ ppr occ <> colon <> ppr ref) <+> dcolon <+> ppr ty

     = braces $ ppr occ <> colon <> ppr ty

 instance Outputable HoleSort where

 -- | Why did we require that a certain type be concrete?

 data NotConcreteError

     fail_tyvar reason (WithUserRdr rdr nm) =

       fail_with_msg reason WL_Term varName rdr nm (Just TermLevelUseTyVar) TyVarTE

     fail_with_msg reason what_looking whatName rdr nm pprov err = do

       (imp_errs, hints) <- get_suggestions what_looking whatName rdr

       hfdc <- getHoleFitDispConfig

       unit_state <- hsc_units <$> getTopEnv

       let

         want_simple = want_simple_msg hints

         info = ErrInfo { errInfoContext =

                            if want_simple

                            then []

                              NE.nonEmpty imp_errs

                        , errInfoHints = hints

                        }

     get_suggestions what_looking ns rdr = do

       required_type_arguments <- xoptM LangExt.RequiredTypeArguments

   emitWantedEqs, emitNewExprHole,

   newTcEvBinds, newNoTcEvBinds, addTcEvBind,

   newCoercionHole, fillCoercionHole, isFilledCoercionHole,

   checkCoercionHole,

        ; return new_cv }

 -- | Emit a new wanted expression hole

                 -> Type -> TcM HoleExprRef

   = do { u <- newUnique

        ; ref <- newTcRef (pprPanic "unfilled unbound-variable evidence" (ppr u))

        ; let her = HER ref ty u

        ; loc <- getCtLocM (ExprHoleOrigin (Just occ)) (Just TypeLevel)

                          , hole_occ  = occ

                          , hole_ty   = ty

                          , hole_loc  = loc }

        ; emitHole hole

        ; return her }

 newDict :: Class -> [TcType] -> TcM DictId

 newDict cls tys

   = do { name <- newSysName (mkDictOcc (getOccName cls))

 module T19966 where

 import Data.Proxy

 -- "I" is out of scope, but we accept the definition

     Data constructor not in scope: I

     • Data constructor out of scope: ‘Bool’.

       NB: the type constructor ‘Bool’ cannot appear in this position.

     • In the expression: Bool

       In an equation for ‘ex2’: ex2 = Bool

     • Illegal term-level use of the type variable ‘a’

     • In the first argument of ‘not’, namely ‘a’

       In the expression: not a

       In an equation for ‘ex3’: ex3 _ = not a

     • Data constructor not in scope: I

     • In an equation for ‘ex1’: ex1 = I

 (deferred type error)

 (deferred type error)

     • Illegal term-level use of the type variable ‘a’

 (deferred type error)