{-# LANGUAGE MultiWayIf #-}

 {-# LANGUAGE ParallelListComp #-}

 {-# LANGUAGE NondecreasingIndentation #-}

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

 --

 import GHC.Types.Tickish ( GenTickish(..) )

 import GHC.Types.SrcLoc  ( srcSpanFile, srcSpanStartLine, srcSpanStartCol )

 -- The rest:

 import GHC.Data.Maybe ( expectJust )

 import GHC.Types.ForeignCall ( CCallConv(..) )

 getRegisterReg platform  (CmmGlobal mid)

   = case globalRegMaybe platform $ globalRegUse_reg mid of

         Nothing  -> pprPanic "getRegisterReg-memory" (ppr $ CmmGlobal mid)

         -- By this stage, the only MagicIds remaining should be the

         -- ones which map to a real machine register on this

   -- | The code to assign arguments to registers used for argument passing.

   , assignArgsCode :: InstrBlock

   }

 -- | An argument passed on the stack, either directly or by reference.

 --

 {-# LANGUAGE CPP #-}

 {-# LANGUAGE MultiWayIf #-}

 {-# OPTIONS_GHC -fno-warn-type-defaults #-}

 -- | Handle conversion of CmmProc to LLVM code.

 module GHC.CmmToLlvm.CodeGen ( genLlvmProc ) where

 import GHC.Data.Maybe (expectJust)

 import GHC.Data.OrdList

 import GHC.Types.ForeignCall

 import GHC.Types.Unique.DSM

 import GHC.Types.Unique

 import qualified Data.List as List

 import Data.List.NonEmpty ( NonEmpty (..), nonEmpty )

 import Data.Maybe ( catMaybes )

 type Atomic = Maybe MemoryOrdering

 type LlvmStatements = OrdList LlvmStatement

 -- | A more convenient way of accumulating LLVM statements and declarations.

 data LlvmAccum = LlvmAccum LlvmStatements [LlvmCmmDecl]

 liftExprData :: LlvmM ExprData -> WriterT LlvmAccum LlvmM LlvmVar

 liftExprData action = do

 {-

 A simple homogeneous pair type with useful Functor, Applicative, and

 Traversable instances.

 import GHC.Utils.Outputable

 import qualified Data.Semigroup as Semi

 data Pair a = Pair { pFst :: a, pSnd :: a }

 -- Note that Pair is a *unary* type constructor

 -- whereas (,) is binary

   pure x = Pair x x

   (Pair f g) <*> (Pair x y) = Pair (f x) (g y)

 instance Outputable a => Outputable (Pair a) where

   ppr (Pair a b) = ppr a <+> char '~' <+> ppr b

 {-# LANGUAGE TypeFamilies #-}

 {-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]

                                        -- in module Language.Haskell.Syntax.Extension

 {-# OPTIONS_GHC -Wno-orphans #-} -- NamedThing, Outputable, OutputableBndrId

 {-

 import GHC.Core.Type

 import GHC.Core.Multiplicity( pprArrowWithModifiers )

 import GHC.Hs.Doc

 import GHC.Types.Basic

 import GHC.Types.SrcLoc

 import GHC.Utils.Outputable

     hstpb_imp_tvs :: Bag Name,

     hstpb_exp_tvs :: Bag Name

   }

 tpBuilderExplicitTV :: Name -> HsTyPatRnBuilder

 tpBuilderExplicitTV name = mempty {hstpb_exp_tvs = unitBag name}

     hstpb_imp_tvs = listToBag hsps_imp_tvs

   }

 buildHsTyPatRn :: HsTyPatRnBuilder -> HsTyPatRn

 buildHsTyPatRn HsTPRnB {hstpb_nwcs, hstpb_imp_tvs, hstpb_exp_tvs} =

   HsTPRn {

 -- | This module coverage checks pattern matches. It finds

 --

 --     * Uncovered patterns, certifying non-exhaustivity

 import GHC.HsToCore.Monad

 import GHC.Data.Bag

 import GHC.Data.OrdList

 import Control.Monad (when, forM_)

 import qualified Data.Semigroup as Semi

   , cirb_red   :: !(OrdList SrcInfo) -- ^ Redundant clauses

   , cirb_bangs :: !(OrdList SrcInfo) -- ^ Redundant bang patterns

   }

 -- See Note [Determining inaccessible clauses]

 ensureOneNotRedundant :: CIRB -> CIRB

 {-# LANGUAGE ViewPatterns        #-}

 {-# LANGUAGE MultiWayIf          #-}

 {-# LANGUAGE TypeFamilies        #-}

 -- | Domain types used in "GHC.HsToCore.Pmc.Solver".

 -- The ultimate goal is to define 'Nabla', which models normalised refinement

 import GHC.Types.SourceText (SourceText(..), mkFractionalLit, FractionalLit

                             , fractionalLitFromRational

                             , FractionalExponentBase(..))

 import Numeric (fromRat)

 import Data.Ratio

 -- | A disjunctive bag of 'Nabla's, representing a refinement type.

 newtype Nablas = MkNablas (Bag Nabla)

 initNablas :: Nablas

 initNablas = MkNablas (unitBag initNabla)

 -- | The type oracle state. An 'GHC.Tc.Solver.Monad.InertSet' that we

 -- incrementally add local type constraints to, together with a sequence

 -- number that counts the number of times we extended it with new facts.

 {-# LANGUAGE ApplicativeDo              #-}

 {-# LANGUAGE DerivingVia                #-}

 {-# LANGUAGE TypeFamilies               #-}

 import GHC.Parser.Lexer

 import GHC.Parser.HaddockLex

 import GHC.Parser.Errors.Types

 import GHC.Utils.Misc (mergeListsBy, filterOut, (<&&>))

 import qualified GHC.Data.Strict as Strict

     { loc_range_from :: !LowerLocBound,

       loc_range_to   :: !UpperLocBound,

       loc_range_col  :: !ColumnBound }

 -- The location range from the specified position to the end of the file.

 locRangeFrom :: Strict.Maybe BufPos -> LocRange

 {-# LANGUAGE DuplicateRecordFields #-}

 {-# LANGUAGE MultiWayIf            #-}

 {-# LANGUAGE RecursiveDo           #-}

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

 {-

 import GHC.Utils.Panic

 import GHC.Utils.Constants (debugIsOn)

 import Control.Monad

 import Data.IORef

 import GHC.Data.Maybe

 import GHC.Types.Name.Reader

 {-

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

 *                                                                      *

          -- These are covars. Included only so that we don't repeatedly

          -- look at covars' kinds in accumulator. Not used by quantifyTyVars.

     }

 instance Outputable CandidatesQTvs where

   ppr (DV {dv_kvs = kvs, dv_tvs = tvs, dv_cvs = cvs })

 import Data.Coerce

 import Data.Data

 -- See Note [UniqSet invariant] in GHC.Types.Unique.Set for why we want a newtype here.

 -- Beyond preserving invariants, we may also want to 'override' typeclass

 pprUniqDSet :: (a -> SDoc) -> UniqDSet a -> SDoc

 pprUniqDSet f = braces . pprWithCommas f . uniqDSetToList

 module GHC.Utils.Ppr.Colour where

 import GHC.Prelude.Basic

 import Data.Maybe (fromMaybe)

 import GHC.Data.Bool

 -- | A colour\/style for use with 'coloured'.

 newtype PprColour = PprColour { renderColour :: String }

 renderColourAfresh :: PprColour -> String

 renderColourAfresh c = renderColour (colReset `mappend` c)