import GHC.Builtin.Uniques

 import GHC.Builtin.Names.TH( thKnownKeyTable )

 import GHC.Utils.Panic

 import GHC.Utils.Misc( HasDebugCallStack )

         Just occ -> occ

         Nothing  -> pprPanic "knownKeyOccName" (pprKnownKey std_uniq)

 basicKnownKeyTable :: [(OccName, KnownKeyNameKey)]

 basicKnownKeyTable

   = [ (mkTcOcc "Rational",     rationalTyConKey)

 eqClassOpKey                  = mkPreludeMiscIdUnique 167

 geClassOpKey                  = mkPreludeMiscIdUnique 168

 negateClassOpKey              = mkPreludeMiscIdUnique 169

 thenMClassOpKey               = mkPreludeMiscIdUnique 172 -- (>>)

 fmapClassOpKey                = mkPreludeMiscIdUnique 173

 returnMClassOpKey             = mkPreludeMiscIdUnique 174

 dsLookupKnownKey uniq

   = do { rebindable_path <- goptM Opt_RebindableKnownKeyNames

        ; mb_rdr_env <- if rebindable_path

                        else return KKNS_FromModule

        ; dsToIfL $

          do { mb_res <- lookupKnownKeyThing mb_rdr_env uniq

 interfaceErrorHints = \ case

   Can'tFindInterface err _looking_for ->

     missingInterfaceErrorHints err

 missingInterfaceErrorHints :: MissingInterfaceError -> [GhcHint]

 missingInterfaceErrorHints = \case

   = missingInterfaceErrorReason err

 interfaceErrorReason (Can'tFindNameInInterface {})

   = ErrorWithoutFlag

 missingInterfaceErrorReason :: MissingInterfaceError -> DiagnosticReason

 missingInterfaceErrorReason = \ case

   CircularImport mod ->

     text "Circular imports: module" <+> quotes (ppr mod)

     <+> text "depends on itself"

 lookingForHerald :: InterfaceLookingFor -> SDoc

 lookingForHerald looking_for =

 import GHC.Prelude

 import GHC.Types.TyThing (TyThing)

 import GHC.Unit.Types (Module, InstalledModule, UnitId, Unit)

 import GHC.Unit.State (UnitState, ModuleSuggestion, ModuleOrigin, UnusableUnit, UnitInfo)

   = Can'tFindInterface

       MissingInterfaceError

       InterfaceLookingFor

   | Can'tFindNameInInterface

       Name

       [TyThing] -- possibly relevant TyThings

   | CircularImport !Module

   deriving Generic

 data MissingInterfaceError

                     => KnownKeyNameSource -> KnownKeyNameKey

                     -> IfM lcl (MaybeErr IfaceMessage TyThing)

 lookupKnownKeyThing mb_gbl_rdr_env key

 lookupKnownKeyName :: HasDebugCallStack

                    => KnownKeyNameSource -> KnownKeyNameKey

 lookupKnownKeyName KKNS_FromModule uniq

   = do { known_key_name_map :: UniqFM KnownKeyNameKey Name <- loadKnownKeyOccMap

 lookupKnownKeyName (KKNS_InScope gbl_rdr_env) uniq

   -- Just gbl_rdr_env: we have -frebindable-known-key-names on, and

   --                   here is the top-level GlobalRdrEnv

   -- Look up the known-key OccName in the GlobalRdrEnv

   -- If we get a unique hit, use it; if not, panic.

   = case lookupGRE gbl_rdr_env (LookupOccName occ SameNameSpace) of

        [gre] -> do { let name = greName gre

                    ; traceIf $ hang (text "lookupKnownKeyThing NoImplicitKnownKeyNames")

                                   2 (ppr name <+> ppr uniq)

 loadKnownKeyOccMap :: IfM lcl KnownKeyNameMap

 loadKnownKeyOccMap

         lookupSyntax, lookupSyntaxExpr,

         lookupSyntaxName,

         lookupIfThenElse,

         -- Constructing usage information

         DeprecationWarnings(..),

 import GHC.Types.PkgQual

 import GHC.Types.GREInfo

 import Control.Monad

 import Data.Either      ( partitionEithers )

 import Data.Function    ( on )

   = do { (expr, fvs) <- lookupSyntaxExpr std_uniq

        ; return (SyntaxExprRn expr, fvs) }

   = do { qname <- lookupOccRnNone $

                   mkRdrQual modName (knownKeyOccName std_uniq)

        ; return (qname, unitFV qname) }

 -- Helper functions for 'isIrrefutableHsPat'.

 --

 -- (Defined here to avoid import cycles.)

       | otherwise

       = go comps

 rnStmt ctxt rnBody (L loc (BodyStmt _ (L lb body) _ _)) thing_inside

   = do  { (body', fv_expr) <- rnBody body

         ; (guard_op, fvs2) <- if isComprehensionContext ctxt

                               then lookupQualifiedDoStmtName ctxt guardMIdKey

     dupErr vs = addErr $ TcRnListComprehensionDuplicateBinding (NE.head vs)

 lookupQualifiedDoStmtName :: HasDebugCallStack => HsStmtContextRn

                           -> KnownKeyNameKey -> RnM (SyntaxExpr GhcRn, FreeVars)

 lookupQualifiedDoStmtName ctxt n

 lookupQualifiedDoStmtNameE :: HasDebugCallStack => HsStmtContextRn

                            -> KnownKeyNameKey -> RnM (HsExpr GhcRn, FreeVars)

 lookupQualifiedDoStmtNameE ctxt key

        ; return (genHsVar nm, fvs) }

   | otherwise  -- Respect -XRebindableSyntax

 -- | Is this a context where we respect RebindableSyntax?

 -- but ListComp are never rebindable

   GhciStmtCtxt -> True   -- I suppose?

 {-

 ************************************************************************

 *                                                                      *

 \subsubsection{mdo expressions}

         -- Turns each stmt into a singleton Stmt

 rn_rec_stmt ctxt rnBody _ (L loc (LastStmt _ (L lb body) noret _), _)

   = do  { (body', fv_expr) <- rnBody body

         ; return [(emptyNameSet, fv_expr `plusFV` fvs1, emptyNameSet,

                    L loc (LastStmt noExtField (L lb body') noret ret_op))] }

 rn_rec_stmt ctxt rnBody _ (L loc (BodyStmt _ (L lb body) _ _), _)

   = do { (body', fvs) <- rnBody body

        ; return [(emptyNameSet, fvs `plusFV` fvs1, emptyNameSet,

                  L loc (BodyStmt noExtField (L lb body') then_op noSyntaxExpr))] }

 rn_rec_stmt ctxt rnBody _ (L loc (BindStmt _ pat' (L lb body)), fv_pat)

   = do { (body', fv_expr) <- rnBody body

        ; (fail_op, fvs2) <- getMonadFailOp ctxt

 -- If the do-block contains a single @return@ statement, change it to

 -- @pure@ if ApplicativeDo is turned on. See Note [ApplicativeDo].

 rearrangeForApplicativeDo ctxt [(one,_)] = do

   let monad_names = MonadNames { return_name = return_name

                                , pure_name   = pure_name }

   return $ case needJoin monad_names [one] (Just pure_name) of

   let stmt_tree | optimal_ado = mkStmtTreeOptimal stmts

                 | otherwise = mkStmtTreeHeuristic stmts

   traceRn "rearrangeForADo" (ppr stmt_tree)

   let monad_names = MonadNames { return_name = return_name

                                , pure_name   = pure_name }

   stmtTreeToStmts monad_names ctxt stmt_tree [last] last_fvs

        }] False tail'

 stmtTreeToStmts monad_names ctxt (StmtTreeOne (let_stmt@(L _ LetStmt{}),_))

                 tail _tail_fvs = do

   return $ case needJoin monad_names tail (Just pure_name) of

     (False, tail') -> (let_stmt : tail', emptyNameSet)

     (True, _) -> (let_stmt : tail, emptyNameSet)

            | otherwise -> do

              -- Need 'pureAClassOpKey' and not 'returnMClassOpKey' here, so that it requires

              -- 'Applicative' and not 'Monad' whenever possible (until #20540 is fixed).

              let expr = HsApp noExtField (noLocA (genHsVar pure_name)) tup

              return (expr, emptyFVs)

      return ( ApplicativeArgMany

                         Nothing -> M.fail (fromString "Pattern match error")

 -}

 getMonadFailOp ctxt

  = do { xOverloadedStrings <- fmap (xopt LangExt.OverloadedStrings) getDynFlags

       ; xRebindableSyntax <- fmap (xopt LangExt.RebindableSyntax) getDynFlags

     reallyGetMonadFailOp rebindableSyntax overloadedStrings

       | (isQualifiedDo || rebindableSyntax) && overloadedStrings = do

         (fromStringExpr, fromStringFvs) <- lookupSyntaxExpr fromStringClassOpKey

         let arg_lit = mkVarOccFS (fsLit "arg")

         arg_name <- newSysName arg_lit

         let failAfterFromStringSynExpr :: SyntaxExpr GhcRn =

               mkSyntaxExpr failAfterFromStringExpr

         return (failAfterFromStringSynExpr, failFvs `plusFV` fromStringFvs)

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

         case ql_val of

           -- See Note [Implementation of QualifiedStrings]

           HsQualString st s -> (fromStringClassOpKey, HsString st s)

   let lit = QualLit{ql_ext = L noAnn funName, ..}

   let expr = genHsApps funName [genLHsLit hsLit]

   pure ((lit, expr), fvs)

     unused_decl :: LImportDecl GhcRn -> ImportDeclUsage

     unused_decl decl@(L _ (ImportDecl { ideclImportList = imps }))

       where

         used_gres = lookupImportMap decl import_usage

               (flds, flds_used) = lookupFsEnv acc_fs fs `orElse` (emptyNameSet, Any False)

               acc_fs' = extendFsEnv acc_fs fs (extendNameSet flds n, Any used S.<> flds_used)

             in UnusedNames acc_ns acc_wcs acc_fs'

           | used

           = acc

 import GHC.Data.FastString ( uniqCompareFS )

 import GHC.Data.List.SetOps( removeDups )

 import GHC.Utils.Misc

 import GHC.Utils.Panic.Plain

 import GHC.Types.SrcLoc

 getKnownKeySource

   = do { rebindable_path <- goptM Opt_RebindableKnownKeyNames

        ; if rebindable_path

          else return KKNS_FromModule }

 rnLookupKnownKeyName :: HasDebugCallStack => KnownKeyNameKey -> RnM Name

 rnLookupKnownKeyName uniq

   = do { kk_source <- getKnownKeySource

 rnLookupKnownKeyRdr :: HasDebugCallStack => KnownKeyNameKey -> RnM RdrName

 rnLookupKnownKeyRdr uniq

   GhcDiagnosticCode "CircularImport"                                = 75429

   GhcDiagnosticCode "HiModuleNameMismatchWarn"                      = 53693

   GhcDiagnosticCode "ExceptionOccurred"                             = 47808

   -- Out of scope errors

   GhcDiagnosticCode "NotInScope"                                    = 76037

         -- * The main types

         Name,                                   -- Abstract

         BuiltInSyntax(..),

         -- ** Creating 'Name's

         mkSystemName, mkSystemNameAt,

 mk_known_key_name space modu str unique

   = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan

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

 import GHC.Internal.Show

 import GHC.Internal.Types (Bool, Int(..), Ordering(..), isTrue#)

 infixl 9  !, //

 default ()

 import GHC.Internal.Prim (seq)

 import GHC.Internal.ST

 import GHC.Internal.STRef

 -- $setup

 -- >>> import Prelude

 import GHC.Internal.TypeNats.Internal

 import GHC.Internal.Types (Bool(..), Char, Ordering(..), type (~))

 -- | 'Compare' branches on the kind of its arguments to either compare by

 -- 'Symbol' or 'Nat'.

 --

     , writeIntVar

     ) where

 import GHC.Internal.Bits

 import GHC.Internal.Prim (

     MutableByteArray#, RealWorld, newByteArray#, readIntArray#, writeIntArray#,

   )

 import GHC.Internal.Types (Int(..), IO(..))

 data IntVar = IntVar (MutableByteArray# RealWorld)

 newIntVar :: Int -> IO IntVar

   )

 import GHC.Internal.Types(Int(..), IO(..))

 #include "MachDeps.h"

 data UniqueSource = US (MutableByteArray# RealWorld)

   )

 import GHC.Internal.Types (Double(..), Float(..), Int(..), isTrue#)

 #if WORD_SIZE_IN_BITS < 64

 import GHC.Internal.Prim (

   )

 import GHC.Internal.Types (Int(..), Word(..))

 infixl 7  *

 infixl 6  +, -

 import GHC.Internal.Prim (State#, noDuplicate#)

 import GHC.Internal.Show

 default ()

 -- The 'ST' monad proper.  By default the monad is strict;