import GHC.Utils.Outputable

 import GHC.Utils.Binary

 import GHC.Types.Name

 import GHC.Utils.Misc ((<||>))

 import Data.Data (Data)

 -- @

 data NamespaceSpecifier

   = NoNamespaceSpecifier

   deriving (Eq, Data)

 -- | Check if namespace specifiers overlap, i.e. if they are equal or

 import GHC.Types.Avail

 import GHC.Types.Name.Set

 import GHC.Driver.Flags

 import Control.DeepSeq

 import Data.Data

 import GHC.Hs.DocString

 import Language.Haskell.Syntax.Extension

 import Language.Haskell.Syntax.Module.Name

   rnf (WithHsDocIdentifiers d i) = rnf d `seq` rnf i

 -- | For compatibility with the existing @-ddump-parsed' output, we only show

 instance Outputable a => Outputable (WithHsDocIdentifiers a pass) where

   ppr (WithHsDocIdentifiers s _ids) = ppr s

   put_ bh (WithHsDocIdentifiers s ids) = do

     put_ bh s

   get bh =

 -- | Extract a mapping from the lexed identifiers to the names they may

 -- correspond to.

 -- and will come either before or after depending on how it was written

 -- i.e it will come after the thing if it is a '-- ^' or '{-^' and before

 -- otherwise.

 pprWithDoc doc = pprWithDocString (hsDocString $ unLoc doc)

 -- | See 'pprWithHsDoc'

 pprMaybeWithDoc Nothing    = id

 pprMaybeWithDoc (Just doc) = pprWithDoc doc

 -- | Print a doc with its identifiers, useful for debugging

 pprHsDocDebug (WithHsDocIdentifiers s ids) =

     vcat [ text "text:" $$ nest 2 (pprHsDocString s)

          ]

 -- | A simplified version of 'HsImpExp.IE'.

 data DocStructureItem

                             -- ^ Invariant: This list of Avails must be sorted

                             -- to guarantee interface file determinism.

 instance Binary DocStructureItem where

   put_ bh = \case

     DsiSectionHeading level doc -> do

       3 -> DsiExports <$> get bh

       4 -> DsiModExport <$> get bh <*> get bh

       _ -> fail "instance Binary DocStructureItem: Invalid tag"

 instance Outputable DocStructureItem where

   ppr = \case

 instance NFData DocStructureItem where

   rnf = \case

     DsiNamedChunkRef name -> rnf name

     DsiExports avails -> rnf avails

     DsiModExport mod_names avails -> rnf mod_names `seq` rnf avails

 instance NFData Docs where

   rnf (Docs mod_hdr exps decls args structure named_chunks haddock_opts language extentions)

     = rnf mod_hdr `seq` rnf exps `seq` rnf decls `seq` rnf args `seq` rnf structure `seq` rnf named_chunks

     `seq` rnf haddock_opts `seq` rnf language `seq` rnf extentions

     `seq` ()

 instance Binary Docs where

   put_ bh docs = do

     put_ bh (docs_mod_hdr docs)

               , docs_language = language

               , docs_extensions = exts

               }

 instance Outputable Docs where

   ppr docs =

 -- | An exactprintable structure for docstrings

 module GHC.Hs.DocString

   ( LHsDocString

   , HsDocString(..)

   , HsDocStringDecorator(..)

   , HsDocStringChunk(..)

   , LHsDocStringChunk

 import GHC.Prelude

 import GHC.Utils.Binary

 import GHC.Utils.Encoding

 import GHC.Utils.Outputable as Outputable hiding ((<>))

 import Data.Data

 import Data.List.NonEmpty (NonEmpty(..))

 import Data.List (intercalate)

 -- | Haskell Documentation String

 --

 -- Rich structure to support exact printing

      -- This is because it may contain unbalanced pairs of '{-' and '-}' and

      -- not form a valid 'NestedDocString'

   deriving (Eq, Data, Show)

 instance NFData HsDocString where

   rnf (MultiLineDocString a b) = rnf a `seq` rnf b

   rnf (NestedDocString a b) = rnf a `seq` rnf b

   rnf (GeneratedDocString a) = rnf a

   put_ bh x = case x of

       putByte bh 0

       put_ bh dec

       put_ bh $ BinLocated <$> xs

       putByte bh 1

       put_ bh dec

       put_ bh $ BinLocated x

       putByte bh 2

       put_ bh x

   get bh = do

     tag <- getByte bh

     case tag of

       t -> fail $ "HsDocString: invalid tag " ++ show t

 data HsDocStringDecorator

   = HsDocStringNext -- ^ '|' is the decorator

   | HsDocStringPrevious -- ^ '^' is the decorator

   | HsDocStringNamed !String -- ^ '$<string>' is the decorator

   | HsDocStringGroup !Int -- ^ The decorator is the given number of '*'s

   deriving (Eq, Ord, Show, Data)

 instance Outputable HsDocStringDecorator where

   ppr = text . printDecorator

 instance NFData HsDocStringDecorator where

   rnf HsDocStringNext = ()

   rnf HsDocStringPrevious = ()

   rnf (HsDocStringNamed x) = rnf x

   rnf (HsDocStringGroup x) = rnf x

 printDecorator :: HsDocStringDecorator -> String

 printDecorator HsDocStringNext = "|"

       3 -> HsDocStringGroup <$> get bh

       t -> fail $ "HsDocStringDecorator: invalid tag " ++ show t

 type LHsDocStringChunk = Located HsDocStringChunk

 -- | A contiguous chunk of documentation

 newtype HsDocStringChunk = HsDocStringChunk ByteString

   deriving stock (Eq,Ord,Data, Show)

   deriving newtype (NFData)

 instance Binary HsDocStringChunk where

   put_ bh (HsDocStringChunk bs) = put_ bh bs

   get bh = HsDocStringChunk <$> get bh

 instance Outputable HsDocStringChunk where

   ppr = text . unpackHDSC

 mkHsDocStringChunk :: String -> HsDocStringChunk

 mkHsDocStringChunk s = HsDocStringChunk (utf8EncodeByteString s)

 mkGeneratedHsDocString :: String -> HsDocString

 mkGeneratedHsDocString = GeneratedDocString . mkHsDocStringChunk

 -- | Pretty print with decorators, exactly as the user wrote it

 pprHsDocString = text . exactPrintHsDocString

 pprHsDocStrings = text . intercalate "\n\n" . map exactPrintHsDocString

 -- | Pretty print with decorators, exactly as the user wrote it

   = unlines' $ ("-- " ++ printDecorator dec ++ unpackHDSC (unLoc x))

             : map (\x -> "--" ++ unpackHDSC (unLoc x)) xs

   = "{-" ++ printDecorator dec ++ unpackHDSC s ++ "-}"

   [] -> ""

   (x:xs) -> unlines' $ ( "-- |" ++ x)

                     : map (\y -> "--"++y) xs

 -- | Just get the docstring, without any decorators

 -- | Don't add a newline to a single string

 unlines' :: [String] -> String

 -- | Just get the docstring, without any decorators

 -- Separates docstrings using "\n\n", which is how haddock likes to render them

 renderHsDocStrings = intercalate "\n\n" . map renderHsDocString

 import GHC.Utils.Outputable hiding ((<>))

 import GHC.Types.SrcLoc (GenLocated(..), unLoc)

 import GHC.Utils.Panic

 {-

 Note [IsPass]

 -- but pass-independent, source location

 type XRecGhc a = GenLocated (Anno a) a

 type instance Anno (WithUserRdr a) = Anno a

 type IsSrcSpanAnn p a = ( Anno (IdGhcP p) ~ EpAnn a,

                           Anno (IdOccGhcP p) ~ EpAnn a,

                           NoAnn a,

                           IsPass p)

 instance UnXRec (GhcPass p) where

   unXRec = unLoc

     , module GHC.Hs.ImpExp

     ) where

 import Language.Haskell.Syntax.Extension

 import Language.Haskell.Syntax.Module.Name

 import Language.Haskell.Syntax.ImpExp

 import Data.Data

 import Data.Maybe

 {-

     }

 instance (OutputableBndrId p

          , Outputable (Anno (IE (GhcPass p)))

          , Outputable (ImportDeclPkgQual (GhcPass p)))

        => Outputable (ImportDecl (GhcPass p)) where

 replaceLWrappedName :: LIEWrappedName GhcPs -> IdP GhcRn -> LIEWrappedName GhcRn

 replaceLWrappedName (L l n) n' = L l (replaceWrappedName n n')

 exportDocstring doc = braces (text "docstring: " <> ppr doc)

     ppr ie@(IEVar       _     var doc) =

       sep $ catMaybes [ ppr <$> ieDeprecation ie

                       , Just $ ppr (unLoc var)

 import Language.Haskell.Syntax.Decls

 import Language.Haskell.Syntax.Decls.Foreign (CType(..), Header(..))

 import Language.Haskell.Syntax.Decls.Overlap (OverlapMode(..))

 import Language.Haskell.Syntax.Extension (Anno)

 import Language.Haskell.Syntax.Binds.InlinePragma (ActivationX(..), InlinePragma(..))

 deriving instance Eq (IEWholeNamespaceExt GhcTc)

 -- deriving instance (DataId name)             => Data (IE name)

 -- deriving instance (Eq name, Eq (IdP name)) => Eq (IE name)

 deriving instance Eq (IE GhcPs)

 deriving instance Data (OverlapMode GhcPs)

 deriving instance Data (OverlapMode GhcRn)

 deriving instance Data (OverlapMode GhcTc)

 import GHC.Core.Ppr ( {- instance OutputableBndr TyVar -} )

 import GHC.Types.SourceText

 import GHC.Core.Type

 import GHC.Utils.Misc (split)

 import GHC.Utils.Outputable

 import GHC.Utils.Panic (panic)

     IfDeprecatedTxt src strs -> DeprecatedTxt src (noLocA <$> map fromIfaceStringLiteralWithNames strs)

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

 fromIfaceStringLiteral :: IfaceStringLiteral -> StringLiteral

 fromIfaceStringLiteral (IfStringLiteral st fs) = StringLiteral st fs Nothing

 module GHC.Parser.Annotation (

   -- * Core Exact Print Annotation types

   EpToken(..), EpUniToken(..),

   SrcSpanAnnA, SrcSpanAnnL, SrcSpanAnnP, SrcSpanAnnC, SrcSpanAnnN,

   SrcSpanAnnLC, SrcSpanAnnLW, SrcSpanAnnLS, SrcSpanAnnLI,

   LocatedE,

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

 import Data.Function (on)

 import Data.List (sortBy)

 import Data.Semigroup

 import GHC.Data.FastString

 import GHC.TypeLits (Symbol, KnownSymbol, symbolVal)

 import GHC.Types.Name

 import GHC.Types.SrcLoc

 import GHC.Utils.Misc

 import GHC.Utils.Outputable hiding ( (<>) )

 import GHC.Utils.Panic

 import qualified GHC.Data.Strict as Strict

 import GHC.Types.SourceText (SourceText (NoSourceText))

 {-

 Note [exact print annotations]

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

     -- and the start of this location is used for the spacing when

     -- exact printing the comment.

     }

 data EpaCommentTok =

   -- Documentation annotations

   | EpaDocOptions      String     -- ^ doc options (prune, ignore-exports, etc)

   | EpaLineComment     String     -- ^ comment starting by "--"

   | EpaBlockComment    String     -- ^ comment in {- -}

 -- Note: these are based on the Token versions, but the Token type is

 -- defined in GHC.Parser.Lexer and bringing it in here would create a loop

 instance Outputable EpaComment where

   ppr x = text (show x)

         deriving (Data, Eq, Functor)

 -- See Note [XRec and Anno in the AST]

 spanAsAnchor :: SrcSpan -> (EpaLocation' a)

 spanAsAnchor ss  = EpaSpan ss

       al_trailing  :: ![TrailingAnn] -- ^ items appearing after the

                                      -- list, such as '=>' for a

                                      -- context

 data AnnListBrackets

   = ListParens (EpToken "(")         (EpToken ")")

       ac_close     :: [EpToken ")"]  -- ^ zero or more closing parentheses.

       } deriving (Data)

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

 -- Annotations for names

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

       apr_loc2      :: EpaLocation,

       apr_type      :: EpToken "type",

       apr_module    :: EpToken "module"

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

 import qualified Data.Semigroup as S

 import System.IO.Unsafe ( unsafePerformIO )

 {-

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

 *                                                                      *

    getGenericSymtab, putGenericSymTab,

    getGenericSymbolTable, putGenericSymbolTable,

    -- * Newtype wrappers

    -- * Newtypes for types that have canonically more than one valid encoding

    BindingName(..),

    simpleBindingNameWriter,

 import Language.Haskell.Syntax.Binds.InlinePragma

 import Language.Haskell.Syntax.Module.Name (ModuleName(..))

 import Language.Haskell.Syntax.ImpExp.IsBoot (IsBootInterface(..))

 import {-# SOURCE #-} GHC.Types.Name (Name)

 import GHC.Data.FastString

             x <- get bh

             return $ BinLocated (L l x)

 newtype BinSpan = BinSpan { unBinSpan :: RealSrcSpan }

 -- See Note [Source Location Wrappers]

       h <- getByte bh

       if h == 1 then pure ConLike

                 else pure FunLike

 import Language.Haskell.Syntax.Binds.InlinePragma

 import Language.Haskell.Syntax.Decls.Overlap ( OverlapMode(..) )

 import Language.Haskell.Syntax.Module.Name ( ModuleName(..) )

 import GHC.Prelude.Basic

   ppr (Incoherent   _) = text "[incoherent]"

   ppr (NonCanonical _) = text "[noncanonical]"

   ppr (XOverlapMode _) = text "[user TTG extension]"

   | DocCommentNamed String (LHsDoc pass)

   | DocGroup Int (LHsDoc pass)

 docDeclDoc :: DocDecl pass -> LHsDoc pass