Nothing       -> empty

     Just (L _ ds) -> ppr ds

 ppOverlapPragma mb =

   case mb of

     Nothing           -> empty

   where

     maybe_stext NoSourceText     alt = text alt

     maybe_stext (SourceText src) _   = ftext src <+> text "#-}"

 instance (OutputableBndrId p) => Outputable (InstDecl (GhcPass p)) where

     ppr (ClsInstD     { cid_inst  = decl }) = ppr decl

 type instance Anno (FamilyResultSig (GhcPass p)) = EpAnnCO

 type instance Anno (FamilyDecl (GhcPass p)) = SrcSpanAnnA

 type instance Anno (InjectivityAnn (GhcPass p)) = EpAnnCO

 type instance Anno (HsDerivingClause (GhcPass p)) = EpAnnCO

 type instance Anno (DerivClauseTys (GhcPass _)) = SrcSpanAnnA

 type instance Anno (StandaloneKindSig (GhcPass p)) = SrcSpanAnnA

 type instance Anno (InstDecl (GhcPass p)) = SrcSpanAnnA

 type instance Anno (DocDecl (GhcPass p)) = SrcSpanAnnA

 type instance Anno (DerivDecl (GhcPass p)) = SrcSpanAnnA

 type instance Anno (DerivStrategy (GhcPass p)) = EpAnnCO

 type instance Anno (DefaultDecl (GhcPass p)) = SrcSpanAnnA

 type instance Anno (ForeignDecl (GhcPass p)) = SrcSpanAnnA

 import GHC.Hs.Extension

 import Language.Haskell.Syntax.Decls.Overlap

 import Language.Haskell.Syntax.Extension

 instance Outputable OverlapFlag where

     ppr flag = ppr (overlapMode flag) <+> pprSafeOverlap (isSafeOverlap flag)

 type instance XXOverlapMode (GhcPass _) = DataConCantHappen

       NewtypeStrategy _ -> []

       ViaStrategy s -> [ toHie (TS (ResolvedScopes [sc]) s) ]

   toHie (L span _) = locOnly (locA span)

 instance ToHie (LocatedA (ConDecl GhcRn)) where

                                    (fmap reverse $7)

                             (AnnDataDefn [] [] NoEpTok tnewtype tdata (epTok $2) dcolon twhere oc cc NoEpTok)}}

   | {- empty -}                 { Nothing }

 deriv_strategy_no_via :: { LDerivStrategy GhcPs }

         | type                      { sL1 $1 (Nothing, mkHsOuterImplicit, $1) }

 capi_ctype : '{-# CTYPE' STRING STRING '#-}'

            | '{-# CTYPE'        STRING '#-}'

            |           { Nothing }

 mkTyData :: SrcSpan

          -> Bool

          -> NewOrData

          -> Located (Maybe (LHsContext GhcPs), LHsType GhcPs)

          -> Maybe (LHsKind GhcPs)

          -> [LConDecl GhcPs]

                                    tcdDataDefn = defn,

                                    tcdModifiers = [] })) }

            -> Maybe (LHsContext GhcPs)

            -> Maybe (LHsKind GhcPs)

            -> DataDefnCons (LConDecl GhcPs)

 mkDataFamInst :: SrcSpan

               -> NewOrData

               -> (Maybe ( LHsContext GhcPs), HsOuterFamEqnTyVarBndrs GhcPs

                         , LHsType GhcPs)

               -> Maybe (LHsKind GhcPs)

 -}

 {-# LANGUAGE TypeFamilies #-}

 module GHC.Stg.Lint ( lintStgTopBindings ) where

 import GHC.Data.Bag         ( Bag, emptyBag, isEmptyBag, snocBag, bagToList )

 import Control.Monad

 import GHC.Core.Multiplicity (scaledThing)

 import GHC.Settings (Platform)

 import GHC.Core.TyCon (primRepCompatible, primRepsCompatible)

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

 -}

               -> [LintLocInfo]     -- Locations

               -> IdSet             -- Local vars in scope

               -> Bag SDoc        -- Error messages so far

               -> (a, Bag SDoc)   -- Result and error messages (if any)

     }

 data LintFlags = LintFlags { lf_unarised :: !Bool

                            , lf_platform :: !Platform

 initL :: Platform -> DiagOpts -> Module -> Bool -> StgPprOpts -> IdSet -> LintM a -> Maybe SDoc

 initL platform diag_opts this_mod unarised opts locals (LintM m) = do

   if isEmptyBag errs then

       Nothing

   else

       Just (vcat (punctuate blankLine (bagToList errs)))

 instance Applicative LintM where

       (<*>) = ap

       (*>)  = thenL_

     (>>)  = (*>)

 thenL :: LintM a -> (a -> LintM b) -> LintM b

 thenL_ :: LintM a -> LintM b -> LintM b

 checkL :: Bool -> SDoc -> LintM ()

 checkL True  _   = return ()

     id_ty = idType id

 addErrL :: SDoc -> LintM ()

 addErr :: DiagOpts -> Bag SDoc -> SDoc -> [LintLocInfo] -> Bag SDoc

 addErr diag_opts errs_so_far msg locs

     mk_msg []      = msg

 addLoc :: LintLocInfo -> LintM a -> LintM a

 addInScopeVars :: [Id] -> LintM a -> LintM a

  -> let

         new_set = mkVarSet ids

 getLintFlags :: LintM LintFlags

 getStgPprOpts :: LintM StgPprOpts

 checkInScope :: Id -> LintM ()

  -> if nameIsLocalOrFrom mod (idName id) && not (id `elemVarSet` scope) then

         ((), addErr diag_opts errs (hsep [ppr id, dcolon, ppr (idType id),

                                     text "is out of scope"]) loc)

 {-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}

 -- | Handles @deriving@ clauses on @data@ declarations.

 import GHC.Prelude

 tcOverlapMode :: OverlapMode GhcRn -> OverlapMode GhcTc

 tcOverlapMode = \case

 -- Typecheck the type in a standalone deriving declaration.

 --

                 -- Dfun location is that of instance *header*

         ; let warn = fmap unLoc lwarn

                               tyvars theta clas inst_tys warn

         ; let inst_binds = InstBindings

 import GHC.Types.Id.Make( mkDictFunId )

 import GHC.Types.Arity ( Arity, VisArity )

 import GHC.Types.Basic ( TypeOrKind(..) )

 import GHC.Types.SrcLoc as SrcLoc

 import GHC.Types.Var.Env

 import GHC.Types.Id

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

 -}

                -> TcM OverlapFlag

 -- Construct the OverlapFlag from the global module flags,

 -- but if the overlap_mode argument is (Just m),

               overlap_mode

                 | Just m <- overlap_mode_prag = m

               -- final_overlap_mode: the `-fspecialise-incoherents` flag controls the

               -- meaning of the `Incoherent` overlap mode: as either an Incoherent overlap

 -- Gets the local class instances.

 tcGetInsts = fmap tcg_insts getGblEnv

            -> Name -> [TyVar] -> ThetaType

            -> Class -> [Type] -> Maybe (WarningTxt GhcRn) -> TcM ClsInst

 newClsInst overlap_mode dfun_name tvs theta clas tys warn

   where

   overlap pragma =

     case pragma of

 import Data.Functor ((<&>))

 import Control.DeepSeq (NFData(..))

 {-

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

 defaultCType :: String -> CType (GhcPass p)

 defaultCType =

 typeCheckCType :: CType GhcRn -> CType GhcTc

 typeCheckCType (CType x y z) = CType x (typeCheckHeader <$> y) z

 data CTypeGhc = CTypeGhc

   { cTypeSourceText :: SourceText

   , cTypeOtherText  :: SourceText

   }

   deriving (Data, Eq)

       return $ CTypeGhc

         { cTypeSourceText = str1

         , cTypeOtherText  = str2

         }

 instance NFData StaticTargetGhc where

 Note [Out-of-bounds error messages]

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

 Ix doesn't have Show as a superclass.  For particular base types we

 can do better, so we override the default method for index.

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

 test('T16721', normal, ghci_script, ['T16721.script'])

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

 test('saks027', req_th, compile, ['-v0 -ddump-splices -dsuppress-uniques'])

 test('saks028', req_th, compile, [''])

 test('T20916', normal, compile_fail, [''])

 test('saks018-fail', normal, compile_fail, [''])

 test('saks021-fail', normal, compile_fail, [''])

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

   -- NOTE: NoOverlap is only used in the typechecker

     o' <- markAnnOpen'' o src "{-# NO_OVERLAP"

     c' <- markEpToken c

     o' <- markAnnOpen'' o src "{-# OVERLAPPABLE"

     c' <- markEpToken c

     o' <- markAnnOpen'' o src "{-# OVERLAPPING"

     c' <- markEpToken c

     o' <- markAnnOpen'' o src "{-# OVERLAPS"

     c' <- markEpToken c

     o' <- markAnnOpen'' o src "{-# INCOHERENT"

     c' <- markEpToken c

     o' <- markAnnOpen'' o src "{-# INCOHERENT"

     c' <- markEpToken c

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

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

     let stp  = cTypeSourceText ext

         stct = cTypeOtherText  ext

     o' <- markAnnOpen'' o stp "{-# CTYPE"

     l1' <- case mh of

              Nothing -> return l1

                printStringAtAA l1 (toSourceTextWithSuffix srcH "" "")

     l2' <- printStringAtAA l2 (toSourceTextWithSuffix stct (unpackHText ct) "")

     c' <- markEpToken c

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

 type instance Anno (HsOuterTyVarBndrs Specificity DocNameI) = SrcSpanAnnA

 type instance Anno (HsSigType DocNameI) = SrcSpanAnnA

 type instance Anno (BooleanFormula DocNameI) = SrcSpanAnnBF

 type instance Anno (Header DocNameI) = EpAnn AnnPragma

 type instance Anno (HsModifierOf (LocatedA (HsType DocNameI)) DocNameI) = SrcSpanAnnA

 type instance Anno (HsContextDetails DocNameI a) = SrcSpanAnnA