-> mkSimpleDecorated $

           text "The" <+> quotes (text "pattern") <+> "namespace specifier is deprecated."

   diagnosticReason  = \case

     PsUnknownMessage m                            -> diagnosticReason m

     PsHeaderMessage  m                            -> psHeaderMessageReason m

     PsErrSpecExprMultipleTypeAscription{}         -> ErrorWithoutFlag

     PsWarnSpecMultipleTypeAscription{}            -> WarningWithFlag Opt_WarnDeprecatedPragmas

     PsWarnPatternNamespaceSpecifier{}             -> WarningWithFlag Opt_WarnPatternNamespaceSpecifier

   diagnosticHints = \case

     PsUnknownMessage m                            -> diagnosticHints m

           let info = text "and replace" <+> quotes (text "pattern")

                         <+> text "with" <+> quotes (text "data") <> "."

           in [useExtensionInOrderTo info LangExt.ExplicitNamespaces]

   diagnosticCode = constructorCode @GHC

    | PsWarnPatternNamespaceSpecifier

       !Bool -- ^ Is ExplicitNamespaces on?

    deriving Generic

 -- | Extra details about a parse error, which helps

   ^\# \ * $idchar+ .*\n   / { ifExtensionGhcCppNotComment } { cppSkip } -- No leading space, otherwise clashes with OverloadedLabels

   ^\# pragma .* \n                      ; -- GCC 3.3 CPP generated, apparently

   ^\# \! .* \n                          ; -- #!, for scripts  -- gcc

 <skipping> {

   -- Ghc CPP symbols

   ^\# \ * @cppkeyword  .* \n  { cppToken cpp_prag }

 }

 -- after a layout keyword (let, where, do, of), we begin a new layout

 ) where

 import Data.List (intercalate, sortBy)

 import Data.Map qualified as Map

 import Debug.Trace (trace)

 import GHC.Data.FastString

 import GHC.Parser.PreProcess.State

 import GHC.Prelude

 import GHC.Types.SrcLoc

 import GHC.Utils.Panic.Plain (panic)

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

                                         pushContinuation tk

                                         contIgnoreTok tk

                                     else do

                                         case mdump of

                                             Just dump ->

                                                 -- We have a dump of the state, put it into an ignored token

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

 processCppToks fs = do

     let

         get (L _ (ITcpp False s _)) = unpackFS s

         get (L _ (ITcpp True s _)) = init $ unpackFS s

     -- Combine any prior continuation tokens

     cs <- popContinuation

     let directive = parseDirective s

     if directive == Right CppDumpState

         then return (Just "\ndumped state\n")

         else do

             case directive of

                 Right (CppInclude filename) -> do

                     ppInclude filename

                 Right (CppDefine name args def) -> do

                     acceptStateChange ar

                 Right CppElse -> do

                     accepting <- getAccepting

                     acceptStateChange ar

                 Right (CppElIf cond) -> do

                     val <- cppCond cond

                     acceptStateChange ar

                 Right CppEndif -> do

                     acceptStateChange ar

                 Right CppDumpState -> do

                     return ()

 acceptStateChange :: AcceptingResult -> PP ()

 acceptStateChange ArNoChange = return ()

 acceptStateChange ArNowIgnoring = do

     Lexer.startSkipping

 acceptStateChange ArNowAccepting = do

     _ <- Lexer.stopSkipping

     return ()

     ghcCppEnabled,

     setInLinePragma,

     getInLinePragma,

 ) where

 import Data.List.NonEmpty ((<|))

 import Data.Maybe (isJust)

 import GHC.Base

 import GHC.Data.StringBuffer

 import GHC.Parser.Lexer (P (..), PState (..), ParseResult (..))

 import GHC.Parser.Lexer qualified as Lexer

 import GHC.Parser.PreProcess.ParserM (Token (..))

 import GHC.Types.SrcLoc

 import GHC.Prelude

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

 -- Note: this is only ever called in the context of a pp group (i.e.

 -- after pushAccepting) from processing #else or #elif

     current <- getAccepting

     parent_scope <- parentScope

     let parent_on = pp_accepting parent_scope

     current_scope <- getScope

     let group_state = pp_group_state current_scope

     let possible_accepting = parent_on && on

     -- let (new_group_state, accepting)

     --       = trace ("setAccepting:" ++ show ((group_state, possible_accepting),  (new_group_state', accepting'))) (new_group_state', accepting')

         _ -> ArNoChange

 -- Exit a scope group

 scopeValue :: NonEmpty PpScope -> Bool

 scopeValue s = pp_accepting $ NonEmpty.head s

          in

             POk s{pp = (pp s){pp_scope = new_scope}} ()

 {-

 Note [PpScope stack]

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

             Just dm -> Map.insert name (Map.insert arity (args, def) dm) md

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

   GhcDiagnosticCode "PsErrSpecExprMultipleTypeAscription"           = 62037

   GhcDiagnosticCode "PsWarnSpecMultipleTypeAscription"              = 73026

   GhcDiagnosticCode "PsWarnPatternNamespaceSpecifier"               = 68383

   -- Driver diagnostic codes

   GhcDiagnosticCode "DriverMissingHomeModules"                      = 32850

      compile,

      ['-ddump-ghc-cpp -dkeep-comments'])

 module PreProcess where

 import Data.List

 import qualified Data.Map as Map

 import Debug.Trace

 import GHC hiding (addSourceToTokens)

 import GHC.Utils.Error

 import GHC.Utils.Outputable

 import GHC.Utils.Panic.Plain

 import Macro

 import ParsePP

                                         pushContinuation tk

                                         contIgnoreTok tk

                                     else do

                                         case mdump of

                                             Just dump ->

                                                 -- We have a dump of the state, put it into an ignored token

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

 processCppToks fs = do

     let

         get (L _ (ITcpp False s _)) = unpackFS s

         get (L _ (ITcpp True s _)) = init $ unpackFS s

     -- Combine any prior continuation tokens

     cs <- popContinuation

     let directive = parseDirective s

     if directive == Right CppDumpState

         then return (Just "\ndumped state\n")

         else do

             case directive of

                 Right (CppInclude filename) -> do

                     ppInclude filename

                 Right (CppDefine name args def) -> do

                     acceptStateChange ar

                 Right CppElse -> do

                     accepting <- getAccepting

                     acceptStateChange ar

                 Right (CppElIf cond) -> do

                     val <- cppCond cond

                     acceptStateChange ar

                 Right CppEndif -> do

                     ar <- popAccepting

     ghcCppEnabled,

     setInLinePragma,

     getInLinePragma,

 ) where

 import Data.List.NonEmpty ((<|))

 import Data.Maybe (isJust)

 import GHC.Base

 import GHC.Data.StringBuffer

 import GHC.Parser.Lexer (P (..), PState (..), ParseResult (..))

 import GHC.Types.SrcLoc

 import ParserM (Token (..))

 -- Note: this is only ever called in the context of a pp group (i.e.

 -- after pushAccepting) from processing #else or #elif

     current <- getAccepting

     parent_scope <- parentScope

     let parent_on = pp_accepting parent_scope

     current_scope <- getScope

     let group_state = pp_group_state current_scope

     let possible_accepting = parent_on && on

             case (group_state, possible_accepting) of

     -- let (new_group_state, accepting)

     --       = trace ("setAccepting:" ++ show ((group_state, possible_accepting),  (new_group_state', accepting'))) (new_group_state', accepting')

             Just dm -> Map.insert name (Map.insert arity (args, def) dm) md

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