{-# LANGUAGE CPP             #-}
{-# LANGUAGE PatternSynonyms #-}
{-# HLINT ignore "Unused LANGUAGE pragma" #-}

-- | Parser compatibility module.
module Development.IDE.GHC.Compat.Parser (
    initParserOpts,
    initParserState,
#if !MIN_VERSION_ghc(9,2,0)
    -- in GHC == 9.2 the type doesn't exist
    -- In GHC == 9.0 it is a data-type
    -- and GHC < 9.0 it is type-def
    --
    -- Export data-type here, otherwise only the simple type.
    Anno.ApiAnns(..),
#else
    ApiAnns,
#endif
    PsSpan(..),
#if MIN_VERSION_ghc(9,2,0)
    pattern HsParsedModule,
    type GHC.HsParsedModule,
    Development.IDE.GHC.Compat.Parser.hpm_module,
    Development.IDE.GHC.Compat.Parser.hpm_src_files,
    Development.IDE.GHC.Compat.Parser.hpm_annotations,
    pattern ParsedModule,
    Development.IDE.GHC.Compat.Parser.pm_parsed_source,
    type GHC.ParsedModule,
    Development.IDE.GHC.Compat.Parser.pm_mod_summary,
    Development.IDE.GHC.Compat.Parser.pm_extra_src_files,
    Development.IDE.GHC.Compat.Parser.pm_annotations,
#else
    GHC.HsParsedModule(..),
    GHC.ParsedModule(..),
#endif
    mkApiAnns,
    -- * API Annotations
    Anno.AnnKeywordId(..),
#if !MIN_VERSION_ghc(9,2,0)
    Anno.AnnotationComment(..),
#endif
    pattern EpaLineComment,
    pattern EpaBlockComment
    ) where

import           Development.IDE.GHC.Compat.Core
import           Development.IDE.GHC.Compat.Util

-- See Note [Guidelines For Using CPP In GHCIDE Import Statements]

import qualified GHC.Parser.Annotation           as Anno
import qualified GHC.Parser.Lexer                as Lexer
import           GHC.Types.SrcLoc                (PsSpan (..))

#if !MIN_VERSION_ghc(9,2,0)
import qualified GHC.Driver.Types                as GHC
#endif

#if !MIN_VERSION_ghc(9,2,0)
import qualified Data.Map                        as Map
import qualified GHC
#endif

#if MIN_VERSION_ghc(9,2,0)
import           GHC                             (EpaCommentTok (..),
                                                  pm_extra_src_files,
                                                  pm_mod_summary,
                                                  pm_parsed_source)
import qualified GHC
import           GHC.Hs                          (hpm_module, hpm_src_files)
#endif

#if MIN_VERSION_ghc(9,2,0) && !MIN_VERSION_ghc(9,3,0)
import qualified GHC.Driver.Config               as Config
#endif

#if MIN_VERSION_ghc(9,3,0)
import qualified GHC.Driver.Config.Parser        as Config
#endif


#if !MIN_VERSION_ghc(9,2,0)
type ParserOpts = Lexer.ParserFlags
#endif

initParserOpts :: DynFlags -> ParserOpts
initParserOpts :: DynFlags -> ParserOpts
initParserOpts =
#if MIN_VERSION_ghc(9,2,0)
  DynFlags -> ParserOpts
Config.initParserOpts
#else
  Lexer.mkParserFlags
#endif

initParserState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState
initParserState :: ParserOpts -> StringBuffer -> RealSrcLoc -> PState
initParserState =
#if MIN_VERSION_ghc(9,2,0)
  ParserOpts -> StringBuffer -> RealSrcLoc -> PState
Lexer.initParserState
#else
  Lexer.mkPStatePure
#endif

#if MIN_VERSION_ghc(9,2,0)
-- GHC 9.2 does not have ApiAnns anymore packaged in ParsedModule. Now the
-- annotations are found in the ast.
type ApiAnns = ()
#else
type ApiAnns = Anno.ApiAnns
#endif

#if MIN_VERSION_ghc(9,2,0)
#if MIN_VERSION_ghc(9,5,0)
pattern HsParsedModule :: Located (HsModule GhcPs) -> [FilePath] -> ApiAnns -> GHC.HsParsedModule
#else
pattern HsParsedModule :: Located HsModule -> [FilePath] -> ApiAnns -> GHC.HsParsedModule
#endif
pattern $bHsParsedModule :: Located HsModule -> [FilePath] -> ApiAnns -> HsParsedModule
$mHsParsedModule :: forall {r}.
HsParsedModule
-> (Located HsModule -> [FilePath] -> ApiAnns -> r)
-> ((# #) -> r)
-> r
HsParsedModule
    { HsParsedModule -> Located HsModule
hpm_module
    , HsParsedModule -> [FilePath]
hpm_src_files
    , HsParsedModule -> ApiAnns
hpm_annotations
    } <- ( (,()) -> (GHC.HsParsedModule{..}, hpm_annotations))
    where
        HsParsedModule Located HsModule
hpm_module [FilePath]
hpm_src_files ApiAnns
_hpm_annotations =
            Located HsModule -> [FilePath] -> HsParsedModule
GHC.HsParsedModule Located HsModule
hpm_module [FilePath]
hpm_src_files
#endif


#if MIN_VERSION_ghc(9,2,0)
pattern ParsedModule :: ModSummary -> ParsedSource -> [FilePath] -> ApiAnns -> GHC.ParsedModule
pattern $bParsedModule :: ModSummary
-> Located HsModule -> [FilePath] -> ApiAnns -> ParsedModule
$mParsedModule :: forall {r}.
ParsedModule
-> (ModSummary -> Located HsModule -> [FilePath] -> ApiAnns -> r)
-> ((# #) -> r)
-> r
ParsedModule
    { ParsedModule -> ModSummary
pm_mod_summary
    , ParsedModule -> Located HsModule
pm_parsed_source
    , ParsedModule -> [FilePath]
pm_extra_src_files
    , ParsedModule -> ApiAnns
pm_annotations
    } <- ( (,()) -> (GHC.ParsedModule{..}, pm_annotations))
    where
        ParsedModule ModSummary
ms Located HsModule
parsed [FilePath]
extra_src_files ApiAnns
_anns =
            GHC.ParsedModule
             { pm_mod_summary :: ModSummary
pm_mod_summary = ModSummary
ms
             , pm_parsed_source :: Located HsModule
pm_parsed_source = Located HsModule
parsed
             , pm_extra_src_files :: [FilePath]
pm_extra_src_files = [FilePath]
extra_src_files
             }
{-# COMPLETE ParsedModule :: GHC.ParsedModule #-}
#endif

mkApiAnns :: PState -> ApiAnns
#if MIN_VERSION_ghc(9,2,0)
mkApiAnns :: PState -> ApiAnns
mkApiAnns = forall a b. a -> b -> a
const ()
#else
mkApiAnns pst =
    -- Copied from GHC.Driver.Main
    Anno.ApiAnns {
            apiAnnItems = Map.fromListWith (++) $ annotations pst,
            apiAnnEofPos = eof_pos pst,
            apiAnnComments = Map.fromList (annotations_comments pst),
            apiAnnRogueComments = comment_q pst
        }
#endif

#if !MIN_VERSION_ghc(9,2,0)
pattern EpaLineComment a = Anno.AnnLineComment a
pattern EpaBlockComment a = Anno.AnnBlockComment a
#endif