[]

   where

     mk_txt msg =

     mk_decl_dep (occ, msg) = (occ, mk_txt msg)

 ghcPrimFixities :: [(OccName,Fixity)]

 cidDeprecation = fmap unLoc . decl_deprecation (ghcPass @p)

   where

     decl_deprecation :: GhcPass p  -> ClsInstDecl (GhcPass p)

     decl_deprecation GhcPs (ClsInstDecl{ cid_ext = (depr, _) } )

       = depr

     decl_deprecation GhcRn (ClsInstDecl{ cid_ext = depr })

     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

 derivDeprecation = fmap unLoc . decl_deprecation (ghcPass @p)

   where

     decl_deprecation :: GhcPass p  -> DerivDecl (GhcPass p)

     decl_deprecation GhcPs (DerivDecl{ deriv_ext = (depr, _) })

       = depr

     decl_deprecation GhcRn (DerivDecl{ deriv_ext = (depr, _) })

 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

     rnf = \case

         NoOverlap    s -> rnf s

         Overlappable s -> rnf s

         Incoherent   s -> rnf s

         NonCanonical s -> rnf s

     put_ bh = \case

         NoOverlap    s -> putByte bh 0 >> put_ bh s

         Overlaps     s -> putByte bh 1 >> put_ bh s

               `extQ` bagName `extQ` bagRdrName `extQ` bagVar `extQ` nameSet

               `ext2Q` located

               `extQ` srcSpanAnnA

               `extQ` srcSpanAnnN

               `extQ` srcSpanAnnBF

             srcSpanAnnA :: EpAnn [TrailingAnn] -> SDoc

             srcSpanAnnA = locatedAnn'' (text "SrcSpanAnnA")

             srcSpanAnnN :: EpAnn NameAnn -> SDoc

             srcSpanAnnN = locatedAnn'' (text "SrcSpanAnnN")

       NewtypeStrategy _ -> []

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

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

 instance ToHie (LocatedA (ConDecl GhcRn)) where

 import GHC.Core.DataCon (SrcStrictness(..), SrcUnpackedness(..))

 import GHC.Builtin.Types ( constraintKindTyConName )

 import GHC.Stg.EnforceEpt.TagSig

 import GHC.Hs.Extension ( GhcPass, GhcRn, GhcTc )

 import GHC.Hs.Decls.Overlap ( OverlapFlag )

 import GHC.Hs.Doc ( WithHsDocIdentifiers(..) )

 fromIfaceWarningTxt :: IfaceWarningTxt -> WarningTxt GhcRn

 fromIfaceWarningTxt = \case

 fromIfaceStringLiteralWithNames :: (IfaceStringLiteral, [IfExtName]) -> WithHsDocIdentifiers StringLiteral GhcRn

 fromIfaceStringLiteralWithNames (str, names) = WithHsDocIdentifiers (fromIfaceStringLiteral str) (map noLoc names)

     ds' = [(occ, toIfaceWarningTxt txt) | (occ, txt) <- ds]

 toIfaceWarningTxt :: WarningTxt GhcRn -> IfaceWarningTxt

 toIfaceStringLiteralWithNames :: WithHsDocIdentifiers StringLiteral GhcRn -> (IfaceStringLiteral, [IfExtName])

 toIfaceStringLiteralWithNames (WithHsDocIdentifiers src names) = (toIfaceStringLiteral src, map unLoc names)

 toIfaceStringLiteral :: StringLiteral -> IfaceStringLiteral

 toIfaceStringLiteral (StringLiteral sl fs _) = IfStringLiteral sl fs

                                    (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 }

 maybe_warning_pragma :: { Maybe (LWarningTxt GhcPs) }

         : '{-# DEPRECATED' strings '#-}'

         | '{-# WARNING' warning_category strings '#-}'

         |  {- empty -}      { Nothing }

 warning_category :: { Maybe (LocatedE (InWarningCategory GhcPs)) }

         : warning_category namespace_spec namelist strings

                 {% fmap unitOL $ amsA' (L (comb4 $1 $2 $3 $4)

                      (Warning (fst $ unLoc $4) (unLoc $2) (unLoc $3)

 namespace_spec :: { Located (NamespaceSpecifier GhcPs) }

   : 'type'      { sL1 $1 $ TypeNamespaceSpecifier (epTok $1) }

 deprecation :: { OrdList (LWarnDecl GhcPs) }

         : namespace_spec namelist strings

              {% fmap unitOL $ amsA' (sL (comb3 $1 $2 $>) $ (Warning (fst $ unLoc $3) (unLoc $1) (unLoc $2)

 strings :: { Located ((EpToken "[", EpToken "]"),[Located StringLiteral]) }

     : STRING             { sL1 $1 (noAnn,[L (gl $1) (getStringLiteral $1)]) }

   EpAnnCO,

   -- ** Annotations in 'GenLocated'

   LocatedE, LocatedBF,

   SrcSpanAnnBF,

   -- ** Annotation data types used in 'GenLocated'

 type LocatedA = GenLocated SrcSpanAnnA

 type LocatedN = GenLocated SrcSpanAnnN

 type LocatedBF = GenLocated SrcSpanAnnBF

 -- | Annotation for items appearing in a list. They can have one or

 -- on the context, such as backticks.

 type SrcSpanAnnN = EpAnn NameAnn

 type SrcSpanAnnBF = EpAnn AnnBooleanFormula

 type LocatedE = GenLocated EpaLocation

 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)

 {-# 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

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

 -}

                -> 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

         }

 cvtDec (InstanceD o ctxt ty decs)

   = do  { decs' <- cvt_ci_decs InstanceDecl decs

         ; let (fams', decls') = partitionWith is_fam_decl decs'

         ; for_ (nonEmpty fams') $ \ bad_fams ->

   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)

     put_ bh ct = do

       put_ bh (cTypeSourceText ct)

       put_ bh (cTypeOtherText  ct)

     get bh = do

       str1 <- get bh

       str2  <- get bh

       return $ CTypeGhc

         { cTypeSourceText = str1

         , cTypeOtherText  = str2

         }

 instance NFData StaticTargetGhc where

 instance Outputable (InWarningCategory (GhcPass pass)) where

   ppr (InWarningCategory _ wt) = text "in" <+> doubleQuotes (ppr wt)

 type instance XXWarningTxt         (GhcPass _) = DataConCantHappen

 type instance XInWarningCategory   (GhcPass _) = (EpToken "in", SourceText)

 type instance XXInWarningCategory  (GhcPass _) = DataConCantHappen

 type instance Anno (WithHsDocIdentifiers StringLiteral pass) = EpaLocation

 type instance Anno (InWarningCategory (GhcPass pass)) = EpaLocation

 type instance Anno (WarningCategory) = EpaLocation

 deriving stock instance Eq (WarningTxt GhcPs)

 deriving stock instance Eq (WarningTxt GhcRn)

 instance Outputable (WarningTxt (GhcPass pass)) where

     ppr (WarningTxt lsrc mcat ws)

       = case lsrc of

         where

           ctg_doc = maybe empty (\ctg -> ppr ctg) mcat

     ppr (DeprecatedTxt lsrc ds)

       = case lsrc of

 pp_ws :: [LocatedE (WithHsDocIdentifiers StringLiteral pass)] -> SDoc

 pp_ws [l] = ppr $ unLoc l

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

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

     mb_cat' <- markAnnotated mb_cat

     os' <- markEpToken os

     ws' <- mapM markAnnotated ws

     cs' <- markEpToken cs

     c' <- markEpToken c

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

     os' <- markEpToken os

     ws' <- mapM markAnnotated ws

     cs' <- markEpToken cs

     c' <- markEpToken c

 instance Typeable p => ExactPrint (InWarningCategory (GhcPass p)) where

   getAnnotationEntry _ = NoEntryVal

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

   -- 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