    {-# LANGUAGE DeriveDataTypeable #-}
    {-# LANGUAGE DeriveTraversable  #-}
    {-# LANGUAGE FlexibleContexts   #-}
    {-# LANGUAGE FlexibleInstances  #-}
    {-# LANGUAGE RecordWildCards    #-}
    {-# LANGUAGE TypeFamilies       #-}

    -- (c) The University of Glasgow, 1992-2006

    -- | This module contains types that relate to the positions of things
    -- in source files, and allow tagging of those things with locations
    module GHC.Types.SrcLoc (
            -- * SrcLoc
            RealSrcLoc,             -- Abstract
            SrcLoc(..),

            -- ** Constructing SrcLoc
            mkSrcLoc, mkRealSrcLoc, mkGeneralSrcLoc,
            leftmostColumn,

            noSrcLoc,               -- "I'm sorry, I haven't a clue"
            generatedSrcLoc,        -- Code generated within the compiler
            interactiveSrcLoc,      -- Code from an interactive session

            advanceSrcLoc,
            advanceBufPos,

            -- ** Unsafely deconstructing SrcLoc
            -- These are dubious exports, because they crash on some inputs
            srcLocFile,             -- return the file name part
            srcLocLine,             -- return the line part
            srcLocCol,              -- return the column part

            -- * SrcSpan
            RealSrcSpan,            -- Abstract
            SrcSpan(..),
            UnhelpfulSpanReason(..),

            -- ** Constructing SrcSpan
            mkGeneralSrcSpan, mkSrcSpan, mkRealSrcSpan,
            noSrcSpan, generatedSrcSpan, isGeneratedSrcSpan,
            wiredInSrcSpan,         -- Something wired into the compiler
            interactiveSrcSpan,
            srcLocSpan, realSrcLocSpan,
            combineSrcSpans,
            srcSpanFirstCharacter,

            -- ** Deconstructing SrcSpan
            srcSpanStart, srcSpanEnd,
            realSrcSpanStart, realSrcSpanEnd,
            srcSpanFileName_maybe,
            pprUserRealSpan, pprUnhelpfulSpanReason,
            pprUserSpan,
            unhelpfulSpanFS,
            srcSpanToRealSrcSpan,

            -- ** Unsafely deconstructing SrcSpan
            -- These are dubious exports, because they crash on some inputs
            srcSpanFile,
            srcSpanStartLine, srcSpanEndLine,
            srcSpanStartCol, srcSpanEndCol,

            -- ** Predicates on SrcSpan
            isGoodSrcSpan, isOneLineSpan, isZeroWidthSpan,
            containsSpan, isNoSrcSpan,

            -- ** Predicates on RealSrcSpan
            isPointRealSpan,

            -- * StringBuffer locations
            BufPos(..),
            getBufPos,
            BufSpan(..),
            getBufSpan,
            removeBufSpan,
            combineBufSpans,

            -- * Located
            Located,
            RealLocated,
            GenLocated(..),

            -- ** Constructing Located
            noLoc,
            mkGeneralLocated,

            -- ** Deconstructing Located
            getLoc, unLoc,
            unRealSrcSpan, getRealSrcSpan,
            pprLocated,
            pprLocatedAlways,

            -- ** Combining and comparing Located values
            eqLocated, cmpLocated, cmpBufSpan,
            combineLocs, addCLoc,
            leftmost_smallest, leftmost_largest, rightmost_smallest,
            spans, isSubspanOf, isRealSubspanOf,
            sortLocated, sortRealLocated,
            lookupSrcLoc, lookupSrcSpan,

            -- * Parser locations
            PsLoc(..),
            PsSpan(..),
            PsLocated,
            advancePsLoc,
            mkPsSpan,
            psSpanStart,
            psSpanEnd,
            mkSrcSpanPs,
            combineRealSrcSpans,
            psLocatedToLocated,

            -- * Exact print locations
            EpaLocation'(..), NoCommentsLocation, NoComments(..),
            DeltaPos(..), deltaPos, getDeltaLine,
        ) where

    import GHC.Prelude

    import GHC.Utils.Misc
    import GHC.Utils.Json
    import GHC.Utils.Outputable
    import GHC.Utils.Panic
    import GHC.Data.FastString
    import qualified GHC.Data.Strict as Strict

    import Control.DeepSeq
    import Data.Data
    import Data.List (sortBy, intercalate)
    import Data.Function (on)
    import qualified Data.Map as Map
    import qualified Data.Semigroup as S

    {-
    ************************************************************************
    *                                                                      *
    \subsection[SrcLoc-SrcLocations]{Source-location information}
    *                                                                      *
    ************************************************************************

    We keep information about the {\em definition} point for each entity;
    this is the obvious stuff:
    -}

    -- | Real Source Location
    --
    -- Represents a single point within a file
    data RealSrcLoc
      = SrcLoc      LexicalFastString       -- A precise location (file name)
                    {-# UNPACK #-} !Int     -- line number, begins at 1
                    {-# UNPACK #-} !Int     -- column number, begins at 1
      deriving (RealSrcLoc -> RealSrcLoc -> Bool
    (RealSrcLoc -> RealSrcLoc -> Bool)
    -> (RealSrcLoc -> RealSrcLoc -> Bool) -> Eq RealSrcLoc
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RealSrcLoc -> RealSrcLoc -> Bool
    == :: RealSrcLoc -> RealSrcLoc -> Bool
    $c/= :: RealSrcLoc -> RealSrcLoc -> Bool
    /= :: RealSrcLoc -> RealSrcLoc -> Bool
    Eq, Eq RealSrcLoc
    Eq RealSrcLoc =>
    (RealSrcLoc -> RealSrcLoc -> Ordering)
    -> (RealSrcLoc -> RealSrcLoc -> Bool)
    -> (RealSrcLoc -> RealSrcLoc -> Bool)
    -> (RealSrcLoc -> RealSrcLoc -> Bool)
    -> (RealSrcLoc -> RealSrcLoc -> Bool)
    -> (RealSrcLoc -> RealSrcLoc -> RealSrcLoc)
    -> (RealSrcLoc -> RealSrcLoc -> RealSrcLoc)
    -> Ord RealSrcLoc
    RealSrcLoc -> RealSrcLoc -> Bool
    RealSrcLoc -> RealSrcLoc -> Ordering
    RealSrcLoc -> RealSrcLoc -> RealSrcLoc
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: RealSrcLoc -> RealSrcLoc -> Ordering
    compare :: RealSrcLoc -> RealSrcLoc -> Ordering
    $c< :: RealSrcLoc -> RealSrcLoc -> Bool
    < :: RealSrcLoc -> RealSrcLoc -> Bool
    $c<= :: RealSrcLoc -> RealSrcLoc -> Bool
    <= :: RealSrcLoc -> RealSrcLoc -> Bool
    $c> :: RealSrcLoc -> RealSrcLoc -> Bool
    > :: RealSrcLoc -> RealSrcLoc -> Bool
    $c>= :: RealSrcLoc -> RealSrcLoc -> Bool
    >= :: RealSrcLoc -> RealSrcLoc -> Bool
    $cmax :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc
    max :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc
    $cmin :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc
    min :: RealSrcLoc -> RealSrcLoc -> RealSrcLoc
    Ord)

    -- | 0-based offset identifying the raw location in the 'StringBuffer'.
    --
    -- The lexer increments the 'BufPos' every time a character (UTF-8 code point)
    -- is read from the input buffer. As UTF-8 is a variable-length encoding and
    -- 'StringBuffer' needs a byte offset for indexing, a 'BufPos' cannot be used
    -- for indexing.
    --
    -- The parser guarantees that 'BufPos' are monotonic. See #17632. This means
    -- that syntactic constructs that appear later in the 'StringBuffer' are guaranteed to
    -- have a higher 'BufPos'. Contrast that with 'RealSrcLoc', which does *not* make the
    -- analogous guarantee about higher line/column numbers.
    --
    -- This is due to #line and {-# LINE ... #-} pragmas that can arbitrarily
    -- modify 'RealSrcLoc'. Notice how 'setSrcLoc' and 'resetAlrLastLoc' in
    -- "GHC.Parser.Lexer" update 'PsLoc', modifying 'RealSrcLoc' but preserving
    -- 'BufPos'.
    --
    -- Monotonicity makes 'BufPos' useful to determine the order in which syntactic
    -- elements appear in the source. Consider this example (haddockA041 in the test suite):
    --
    --  haddockA041.hs
    --      {-# LANGUAGE CPP #-}
    --      -- | Module header documentation
    --      module Comments_and_CPP_include where
    --      #include "IncludeMe.hs"
    --
    --  IncludeMe.hs:
    --      -- | Comment on T
    --      data T = MkT -- ^ Comment on MkT
    --
    -- After the C preprocessor runs, the 'StringBuffer' will contain a program that
    -- looks like this (unimportant lines at the beginning removed):
    --
    --    # 1 "haddockA041.hs"
    --    {-# LANGUAGE CPP #-}
    --    -- | Module header documentation
    --    module Comments_and_CPP_include where
    --    # 1 "IncludeMe.hs" 1
    --    -- | Comment on T
    --    data T = MkT -- ^ Comment on MkT
    --    # 7 "haddockA041.hs" 2
    --
    -- The line pragmas inserted by CPP make the error messages more informative.
    -- The downside is that we can't use RealSrcLoc to determine the ordering of
    -- syntactic elements.
    --
    -- With RealSrcLoc, we have the following location information recorded in the AST:
    --   * The module name is located at haddockA041.hs:3:8-31
    --   * The Haddock comment "Comment on T" is located at IncludeMe:1:1-17
    --   * The data declaration is located at IncludeMe.hs:2:1-32
    --
    -- Is the Haddock comment located between the module name and the data
    -- declaration? This is impossible to tell because the locations are not
    -- comparable; they even refer to different files.
    --
    -- On the other hand, with 'BufPos', we have the following location information:
    --   * The module name is located at 846-870
    --   * The Haddock comment "Comment on T" is located at 898-915
    --   * The data declaration is located at 916-928
    --
    -- Aside:  if you're wondering why the numbers are so high, try running
    --           @ghc -E haddockA041.hs@
    --         and see the extra fluff that CPP inserts at the start of the file.
    --
    -- For error messages, 'BufPos' is not useful at all. On the other hand, this is
    -- exactly what we need to determine the order of syntactic elements:
    --    870 < 898, therefore the Haddock comment appears *after* the module name.
    --    915 < 916, therefore the Haddock comment appears *before* the data declaration.
    --
    -- We use 'BufPos' in in GHC.Parser.PostProcess.Haddock to associate Haddock
    -- comments with parts of the AST using location information (#17544).
    newtype BufPos = BufPos { BufPos -> Int
    bufPos :: Int }
      deriving (BufPos -> BufPos -> Bool
    (BufPos -> BufPos -> Bool)
    -> (BufPos -> BufPos -> Bool) -> Eq BufPos
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BufPos -> BufPos -> Bool
    == :: BufPos -> BufPos -> Bool
    $c/= :: BufPos -> BufPos -> Bool
    /= :: BufPos -> BufPos -> Bool
    Eq, Eq BufPos
    Eq BufPos =>
    (BufPos -> BufPos -> Ordering)
    -> (BufPos -> BufPos -> Bool)
    -> (BufPos -> BufPos -> Bool)
    -> (BufPos -> BufPos -> Bool)
    -> (BufPos -> BufPos -> Bool)
    -> (BufPos -> BufPos -> BufPos)
    -> (BufPos -> BufPos -> BufPos)
    -> Ord BufPos
    BufPos -> BufPos -> Bool
    BufPos -> BufPos -> Ordering
    BufPos -> BufPos -> BufPos
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: BufPos -> BufPos -> Ordering
    compare :: BufPos -> BufPos -> Ordering
    $c< :: BufPos -> BufPos -> Bool
    < :: BufPos -> BufPos -> Bool
    $c<= :: BufPos -> BufPos -> Bool
    <= :: BufPos -> BufPos -> Bool
    $c> :: BufPos -> BufPos -> Bool
    > :: BufPos -> BufPos -> Bool
    $c>= :: BufPos -> BufPos -> Bool
    >= :: BufPos -> BufPos -> Bool
    $cmax :: BufPos -> BufPos -> BufPos
    max :: BufPos -> BufPos -> BufPos
    $cmin :: BufPos -> BufPos -> BufPos
    min :: BufPos -> BufPos -> BufPos
    Ord, Int -> BufPos -> ShowS
    [BufPos] -> ShowS
    BufPos -> String
    (Int -> BufPos -> ShowS)
    -> (BufPos -> String) -> ([BufPos] -> ShowS) -> Show BufPos
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BufPos -> ShowS
    showsPrec :: Int -> BufPos -> ShowS
    $cshow :: BufPos -> String
    show :: BufPos -> String
    $cshowList :: [BufPos] -> ShowS
    showList :: [BufPos] -> ShowS
    Show, Typeable BufPos
    Typeable BufPos =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> BufPos -> c BufPos)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c BufPos)
    -> (BufPos -> Constr)
    -> (BufPos -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c BufPos))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufPos))
    -> ((forall b. Data b => b -> b) -> BufPos -> BufPos)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> BufPos -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> BufPos -> r)
    -> (forall u. (forall d. Data d => d -> u) -> BufPos -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> BufPos -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> BufPos -> m BufPos)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BufPos -> m BufPos)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BufPos -> m BufPos)
    -> Data BufPos
    BufPos -> Constr
    BufPos -> DataType
    (forall b. Data b => b -> b) -> BufPos -> BufPos
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> BufPos -> u
    forall u. (forall d. Data d => d -> u) -> BufPos -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BufPos -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BufPos -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BufPos
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BufPos -> c BufPos
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BufPos)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufPos)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BufPos -> c BufPos
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BufPos -> c BufPos
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BufPos
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BufPos
    $ctoConstr :: BufPos -> Constr
    toConstr :: BufPos -> Constr
    $cdataTypeOf :: BufPos -> DataType
    dataTypeOf :: BufPos -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BufPos)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BufPos)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufPos)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufPos)
    $cgmapT :: (forall b. Data b => b -> b) -> BufPos -> BufPos
    gmapT :: (forall b. Data b => b -> b) -> BufPos -> BufPos
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BufPos -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> BufPos -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BufPos -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> BufPos -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> BufPos -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> BufPos -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BufPos -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BufPos -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufPos -> m BufPos
    Data)

    -- | Source Location
    data SrcLoc
      = RealSrcLoc !RealSrcLoc !(Strict.Maybe BufPos)  -- See Note [Why Maybe BufPos]
      | UnhelpfulLoc !FastString     -- Just a general indication
      deriving (SrcLoc -> SrcLoc -> Bool
    (SrcLoc -> SrcLoc -> Bool)
    -> (SrcLoc -> SrcLoc -> Bool) -> Eq SrcLoc
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SrcLoc -> SrcLoc -> Bool
    == :: SrcLoc -> SrcLoc -> Bool
    $c/= :: SrcLoc -> SrcLoc -> Bool
    /= :: SrcLoc -> SrcLoc -> Bool
    Eq, Int -> SrcLoc -> ShowS
    [SrcLoc] -> ShowS
    SrcLoc -> String
    (Int -> SrcLoc -> ShowS)
    -> (SrcLoc -> String) -> ([SrcLoc] -> ShowS) -> Show SrcLoc
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SrcLoc -> ShowS
    showsPrec :: Int -> SrcLoc -> ShowS
    $cshow :: SrcLoc -> String
    show :: SrcLoc -> String
    $cshowList :: [SrcLoc] -> ShowS
    showList :: [SrcLoc] -> ShowS
    Show)

    {-
    ************************************************************************
    *                                                                      *
    \subsection[SrcLoc-access-fns]{Access functions}
    *                                                                      *
    ************************************************************************
    -}

    mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
    mkSrcLoc :: FastString -> Int -> Int -> SrcLoc
    mkSrcLoc FastString
    x Int
    line Int
    col = RealSrcLoc -> Maybe BufPos -> SrcLoc
    RealSrcLoc (FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc FastString
    x Int
    line Int
    col) Maybe BufPos
    forall a. Maybe a
    Strict.Nothing

    mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc :: FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc FastString
    x Int
    line Int
    col = LexicalFastString -> Int -> Int -> RealSrcLoc
    SrcLoc (FastString -> LexicalFastString
    LexicalFastString FastString
    x) Int
    line Int
    col

    -- | Indentation level is 1-indexed, so the leftmost column is 1.
    leftmostColumn :: Int
    leftmostColumn :: Int
    leftmostColumn = Int
    1

    getBufPos :: SrcLoc -> Strict.Maybe BufPos
    getBufPos :: SrcLoc -> Maybe BufPos
    getBufPos (RealSrcLoc RealSrcLoc
    _ Maybe BufPos
    mbpos) = Maybe BufPos
    mbpos
    getBufPos (UnhelpfulLoc FastString
    _) = Maybe BufPos
    forall a. Maybe a
    Strict.Nothing

    -- | Built-in "bad" 'SrcLoc' values for particular locations
    noSrcLoc, generatedSrcLoc, interactiveSrcLoc :: SrcLoc
    noSrcLoc :: SrcLoc
    noSrcLoc          = FastString -> SrcLoc
    UnhelpfulLoc (String -> FastString
    fsLit String
    "<no location info>")
    generatedSrcLoc :: SrcLoc
    generatedSrcLoc   = FastString -> SrcLoc
    UnhelpfulLoc (String -> FastString
    fsLit String
    "<compiler-generated code>")
    interactiveSrcLoc :: SrcLoc
    interactiveSrcLoc = FastString -> SrcLoc
    UnhelpfulLoc (String -> FastString
    fsLit String
    "<interactive>")

    -- | Creates a "bad" 'SrcLoc' that has no detailed information about its location
    mkGeneralSrcLoc :: FastString -> SrcLoc
    mkGeneralSrcLoc :: FastString -> SrcLoc
    mkGeneralSrcLoc = FastString -> SrcLoc
    UnhelpfulLoc

    -- | Gives the filename of the 'RealSrcLoc'
    srcLocFile :: RealSrcLoc -> FastString
    srcLocFile :: RealSrcLoc -> FastString
    srcLocFile (SrcLoc (LexicalFastString FastString
    fname) Int
    _ Int
    _) = FastString
    fname

    -- | Raises an error when used on a "bad" 'SrcLoc'
    srcLocLine :: RealSrcLoc -> Int
    srcLocLine :: RealSrcLoc -> Int
    srcLocLine (SrcLoc LexicalFastString
    _ Int
    l Int
    _) = Int
    l

    -- | Raises an error when used on a "bad" 'SrcLoc'
    srcLocCol :: RealSrcLoc -> Int
    srcLocCol :: RealSrcLoc -> Int
    srcLocCol (SrcLoc LexicalFastString
    _ Int
    _ Int
    c) = Int
    c

    -- | Move the 'SrcLoc' down by one line if the character is a newline,
    -- to the next 8-char tabstop if it is a tab, and across by one
    -- character in any other case
    advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc
    advanceSrcLoc :: RealSrcLoc -> Char -> RealSrcLoc
    advanceSrcLoc (SrcLoc LexicalFastString
    f Int
    l Int
    _) Char
    '\n' = LexicalFastString -> Int -> Int -> RealSrcLoc
    SrcLoc LexicalFastString
    f  (Int
    l Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Int
    1
    advanceSrcLoc (SrcLoc LexicalFastString
    f Int
    l Int
    c) Char
    '\t' = LexicalFastString -> Int -> Int -> RealSrcLoc
    SrcLoc LexicalFastString
    f  Int
    l (Int -> Int
    advance_tabstop Int
    c)
    advanceSrcLoc (SrcLoc LexicalFastString
    f Int
    l Int
    c) Char
    _    = LexicalFastString -> Int -> Int -> RealSrcLoc
    SrcLoc LexicalFastString
    f  Int
    l (Int
    c Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1)

    advance_tabstop :: Int -> Int
    advance_tabstop :: Int -> Int
    advance_tabstop Int
    c = ((((Int
    c Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1) Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftR` Int
    3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Int -> Int -> Int
    forall a. Bits a => a -> Int -> a
    `shiftL` Int
    3) Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1

    advanceBufPos :: BufPos -> BufPos
    advanceBufPos :: BufPos -> BufPos
    advanceBufPos (BufPos Int
    i) = Int -> BufPos
    BufPos (Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)

    {-
    ************************************************************************
    *                                                                      *
    \subsection[SrcLoc-instances]{Instance declarations for various names}
    *                                                                      *
    ************************************************************************
    -}

    sortLocated :: [Located a] -> [Located a]
    sortLocated :: forall a. [Located a] -> [Located a]
    sortLocated = (Located a -> Located a -> Ordering) -> [Located a] -> [Located a]
    forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy (SrcSpan -> SrcSpan -> Ordering
    leftmost_smallest (SrcSpan -> SrcSpan -> Ordering)
    -> (Located a -> SrcSpan) -> Located a -> Located a -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` Located a -> SrcSpan
    forall l e. GenLocated l e -> l
    getLoc)

    sortRealLocated :: [RealLocated a] -> [RealLocated a]
    sortRealLocated :: forall a. [RealLocated a] -> [RealLocated a]
    sortRealLocated = (RealLocated a -> RealLocated a -> Ordering)
    -> [RealLocated a] -> [RealLocated a]
    forall a. (a -> a -> Ordering) -> [a] -> [a]
    sortBy (RealSrcSpan -> RealSrcSpan -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> (RealLocated a -> RealSrcSpan)
    -> RealLocated a
    -> RealLocated a
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    `on` RealLocated a -> RealSrcSpan
    forall l e. GenLocated l e -> l
    getLoc)

    lookupSrcLoc :: SrcLoc -> Map.Map RealSrcLoc a -> Maybe a
    lookupSrcLoc :: forall a. SrcLoc -> Map RealSrcLoc a -> Maybe a
    lookupSrcLoc (RealSrcLoc RealSrcLoc
    l Maybe BufPos
    _) = RealSrcLoc -> Map RealSrcLoc a -> Maybe a
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup RealSrcLoc
    l
    lookupSrcLoc (UnhelpfulLoc FastString
    _) = Maybe a -> Map RealSrcLoc a -> Maybe a
    forall a b. a -> b -> a
    const Maybe a
    forall a. Maybe a
    Nothing

    lookupSrcSpan :: SrcSpan -> Map.Map RealSrcSpan a -> Maybe a
    lookupSrcSpan :: forall a. SrcSpan -> Map RealSrcSpan a -> Maybe a
    lookupSrcSpan (RealSrcSpan RealSrcSpan
    l Maybe BufSpan
    _) = RealSrcSpan -> Map RealSrcSpan a -> Maybe a
    forall k a. Ord k => k -> Map k a -> Maybe a
    Map.lookup RealSrcSpan
    l
    lookupSrcSpan (UnhelpfulSpan UnhelpfulSpanReason
    _) = Maybe a -> Map RealSrcSpan a -> Maybe a
    forall a b. a -> b -> a
    const Maybe a
    forall a. Maybe a
    Nothing

    instance Outputable RealSrcLoc where
        ppr :: RealSrcLoc -> SDoc
    ppr (SrcLoc (LexicalFastString FastString
    src_path) Int
    src_line Int
    src_col)
          = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hcat [ FastString -> SDoc
    pprFastFilePath FastString
    src_path SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon
                 , Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    src_line SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon
                 , Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    src_col ]

    -- I don't know why there is this style-based difference
    --        if userStyle sty || debugStyle sty then
    --            hcat [ pprFastFilePath src_path, char ':',
    --                   int src_line,
    --                   char ':', int src_col
    --                 ]
    --        else
    --            hcat [text "{-# LINE ", int src_line, space,
    --                  char '\"', pprFastFilePath src_path, text " #-}"]

    instance Outputable SrcLoc where
        ppr :: SrcLoc -> SDoc
    ppr (RealSrcLoc RealSrcLoc
    l Maybe BufPos
    _) = RealSrcLoc -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr RealSrcLoc
    l
        ppr (UnhelpfulLoc FastString
    s)  = FastString -> SDoc
    forall doc. IsLine doc => FastString -> doc
    ftext FastString
    s

    instance Data RealSrcSpan where
      -- don't traverse?
      toConstr :: RealSrcSpan -> Constr
    toConstr RealSrcSpan
    _   = String -> Constr
    abstractConstr String
    "RealSrcSpan"
      gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RealSrcSpan
    gunfold forall b r. Data b => c (b -> r) -> c r
    _ forall r. r -> c r
    _  = String -> Constr -> c RealSrcSpan
    forall a. HasCallStack => String -> a
    error String
    "gunfold"
      dataTypeOf :: RealSrcSpan -> DataType
    dataTypeOf RealSrcSpan
    _ = String -> DataType
    mkNoRepType String
    "RealSrcSpan"

    instance Data SrcSpan where
      -- don't traverse?
      toConstr :: SrcSpan -> Constr
    toConstr SrcSpan
    _   = String -> Constr
    abstractConstr String
    "SrcSpan"
      gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SrcSpan
    gunfold forall b r. Data b => c (b -> r) -> c r
    _ forall r. r -> c r
    _  = String -> Constr -> c SrcSpan
    forall a. HasCallStack => String -> a
    error String
    "gunfold"
      dataTypeOf :: SrcSpan -> DataType
    dataTypeOf SrcSpan
    _ = String -> DataType
    mkNoRepType String
    "SrcSpan"

    {-
    ************************************************************************
    *                                                                      *
    \subsection[SrcSpan]{Source Spans}
    *                                                                      *
    ************************************************************************
    -}

    {- |
    A 'RealSrcSpan' delimits a portion of a text file.  It could be represented
    by a pair of (line,column) coordinates, but in fact we optimise
    slightly by using more compact representations for single-line and
    zero-length spans, both of which are quite common.

    The end position is defined to be the column /after/ the end of the
    span.  That is, a span of (1,1)-(1,2) is one character long, and a
    span of (1,1)-(1,1) is zero characters long.
    -}

    -- | Real Source Span
    data RealSrcSpan
      = RealSrcSpan'
            { RealSrcSpan -> FastString
    srcSpanFile     :: !FastString,
              RealSrcSpan -> Int
    srcSpanSLine    :: {-# UNPACK #-} !Int,
              RealSrcSpan -> Int
    srcSpanSCol     :: {-# UNPACK #-} !Int,
              RealSrcSpan -> Int
    srcSpanELine    :: {-# UNPACK #-} !Int,
              RealSrcSpan -> Int
    srcSpanECol     :: {-# UNPACK #-} !Int
            }
      deriving RealSrcSpan -> RealSrcSpan -> Bool
    (RealSrcSpan -> RealSrcSpan -> Bool)
    -> (RealSrcSpan -> RealSrcSpan -> Bool) -> Eq RealSrcSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: RealSrcSpan -> RealSrcSpan -> Bool
    == :: RealSrcSpan -> RealSrcSpan -> Bool
    $c/= :: RealSrcSpan -> RealSrcSpan -> Bool
    /= :: RealSrcSpan -> RealSrcSpan -> Bool
    Eq

    -- | StringBuffer Source Span
    data BufSpan =
      BufSpan { BufSpan -> BufPos
    bufSpanStart, BufSpan -> BufPos
    bufSpanEnd :: {-# UNPACK #-} !BufPos }
      deriving (BufSpan -> BufSpan -> Bool
    (BufSpan -> BufSpan -> Bool)
    -> (BufSpan -> BufSpan -> Bool) -> Eq BufSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: BufSpan -> BufSpan -> Bool
    == :: BufSpan -> BufSpan -> Bool
    $c/= :: BufSpan -> BufSpan -> Bool
    /= :: BufSpan -> BufSpan -> Bool
    Eq, Eq BufSpan
    Eq BufSpan =>
    (BufSpan -> BufSpan -> Ordering)
    -> (BufSpan -> BufSpan -> Bool)
    -> (BufSpan -> BufSpan -> Bool)
    -> (BufSpan -> BufSpan -> Bool)
    -> (BufSpan -> BufSpan -> Bool)
    -> (BufSpan -> BufSpan -> BufSpan)
    -> (BufSpan -> BufSpan -> BufSpan)
    -> Ord BufSpan
    BufSpan -> BufSpan -> Bool
    BufSpan -> BufSpan -> Ordering
    BufSpan -> BufSpan -> BufSpan
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: BufSpan -> BufSpan -> Ordering
    compare :: BufSpan -> BufSpan -> Ordering
    $c< :: BufSpan -> BufSpan -> Bool
    < :: BufSpan -> BufSpan -> Bool
    $c<= :: BufSpan -> BufSpan -> Bool
    <= :: BufSpan -> BufSpan -> Bool
    $c> :: BufSpan -> BufSpan -> Bool
    > :: BufSpan -> BufSpan -> Bool
    $c>= :: BufSpan -> BufSpan -> Bool
    >= :: BufSpan -> BufSpan -> Bool
    $cmax :: BufSpan -> BufSpan -> BufSpan
    max :: BufSpan -> BufSpan -> BufSpan
    $cmin :: BufSpan -> BufSpan -> BufSpan
    min :: BufSpan -> BufSpan -> BufSpan
    Ord, Int -> BufSpan -> ShowS
    [BufSpan] -> ShowS
    BufSpan -> String
    (Int -> BufSpan -> ShowS)
    -> (BufSpan -> String) -> ([BufSpan] -> ShowS) -> Show BufSpan
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> BufSpan -> ShowS
    showsPrec :: Int -> BufSpan -> ShowS
    $cshow :: BufSpan -> String
    show :: BufSpan -> String
    $cshowList :: [BufSpan] -> ShowS
    showList :: [BufSpan] -> ShowS
    Show, Typeable BufSpan
    Typeable BufSpan =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> BufSpan -> c BufSpan)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c BufSpan)
    -> (BufSpan -> Constr)
    -> (BufSpan -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c BufSpan))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufSpan))
    -> ((forall b. Data b => b -> b) -> BufSpan -> BufSpan)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> BufSpan -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> BufSpan -> r)
    -> (forall u. (forall d. Data d => d -> u) -> BufSpan -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> BufSpan -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan)
    -> Data BufSpan
    BufSpan -> Constr
    BufSpan -> DataType
    (forall b. Data b => b -> b) -> BufSpan -> BufSpan
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> BufSpan -> u
    forall u. (forall d. Data d => d -> u) -> BufSpan -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BufSpan -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BufSpan -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BufSpan
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BufSpan -> c BufSpan
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BufSpan)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufSpan)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BufSpan -> c BufSpan
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> BufSpan -> c BufSpan
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BufSpan
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BufSpan
    $ctoConstr :: BufSpan -> Constr
    toConstr :: BufSpan -> Constr
    $cdataTypeOf :: BufSpan -> DataType
    dataTypeOf :: BufSpan -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BufSpan)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BufSpan)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufSpan)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BufSpan)
    $cgmapT :: (forall b. Data b => b -> b) -> BufSpan -> BufSpan
    gmapT :: (forall b. Data b => b -> b) -> BufSpan -> BufSpan
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BufSpan -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BufSpan -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BufSpan -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BufSpan -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> BufSpan -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> BufSpan -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BufSpan -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BufSpan -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BufSpan -> m BufSpan
    Data)

    instance Semigroup BufSpan where
      BufSpan BufPos
    start1 BufPos
    end1 <> :: BufSpan -> BufSpan -> BufSpan
    <> BufSpan BufPos
    start2 BufPos
    end2 =
        BufPos -> BufPos -> BufSpan
    BufSpan (BufPos -> BufPos -> BufPos
    forall a. Ord a => a -> a -> a
    min BufPos
    start1 BufPos
    start2) (BufPos -> BufPos -> BufPos
    forall a. Ord a => a -> a -> a
    max BufPos
    end1 BufPos
    end2)

    -- | Source Span
    --
    -- A 'SrcSpan' identifies either a specific portion of a text file
    -- or a human-readable description of a location.
    data SrcSpan =
        RealSrcSpan !RealSrcSpan !(Strict.Maybe BufSpan)  -- See Note [Why Maybe BufPos]
      | UnhelpfulSpan !UnhelpfulSpanReason

      deriving (SrcSpan -> SrcSpan -> Bool
    (SrcSpan -> SrcSpan -> Bool)
    -> (SrcSpan -> SrcSpan -> Bool) -> Eq SrcSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: SrcSpan -> SrcSpan -> Bool
    == :: SrcSpan -> SrcSpan -> Bool
    $c/= :: SrcSpan -> SrcSpan -> Bool
    /= :: SrcSpan -> SrcSpan -> Bool
    Eq, Int -> SrcSpan -> ShowS
    [SrcSpan] -> ShowS
    SrcSpan -> String
    (Int -> SrcSpan -> ShowS)
    -> (SrcSpan -> String) -> ([SrcSpan] -> ShowS) -> Show SrcSpan
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> SrcSpan -> ShowS
    showsPrec :: Int -> SrcSpan -> ShowS
    $cshow :: SrcSpan -> String
    show :: SrcSpan -> String
    $cshowList :: [SrcSpan] -> ShowS
    showList :: [SrcSpan] -> ShowS
    Show) -- Show is used by GHC.Parser.Lexer, because we
                          -- derive Show for Token

    data UnhelpfulSpanReason
      = UnhelpfulNoLocationInfo
      | UnhelpfulWiredIn
      | UnhelpfulInteractive
      | UnhelpfulGenerated
      | UnhelpfulOther !FastString
      deriving (UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool
    (UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool)
    -> (UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool)
    -> Eq UnhelpfulSpanReason
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool
    == :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool
    $c/= :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool
    /= :: UnhelpfulSpanReason -> UnhelpfulSpanReason -> Bool
    Eq, Int -> UnhelpfulSpanReason -> ShowS
    [UnhelpfulSpanReason] -> ShowS
    UnhelpfulSpanReason -> String
    (Int -> UnhelpfulSpanReason -> ShowS)
    -> (UnhelpfulSpanReason -> String)
    -> ([UnhelpfulSpanReason] -> ShowS)
    -> Show UnhelpfulSpanReason
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> UnhelpfulSpanReason -> ShowS
    showsPrec :: Int -> UnhelpfulSpanReason -> ShowS
    $cshow :: UnhelpfulSpanReason -> String
    show :: UnhelpfulSpanReason -> String
    $cshowList :: [UnhelpfulSpanReason] -> ShowS
    showList :: [UnhelpfulSpanReason] -> ShowS
    Show)

    removeBufSpan :: SrcSpan -> SrcSpan
    removeBufSpan :: SrcSpan -> SrcSpan
    removeBufSpan (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    _) = RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    forall a. Maybe a
    Strict.Nothing
    removeBufSpan SrcSpan
    s = SrcSpan
    s

    {- Note [Why Maybe BufPos]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~
    In SrcLoc we store (Maybe BufPos); in SrcSpan we store (Maybe BufSpan).
    Why the Maybe?

    Surely, the lexer can always fill in the buffer position, and it guarantees to do so.
    However, sometimes the SrcLoc/SrcSpan is constructed in a different context
    where the buffer location is not available, and then we use Nothing instead of
    a fake value like BufPos (-1).

    Perhaps the compiler could be re-engineered to pass around BufPos more
    carefully and never discard it, and this 'Maybe' could be removed. If you're
    interested in doing so, you may find this ripgrep query useful:

      rg "RealSrc(Loc|Span).*?Nothing"

    For example, it is not uncommon to whip up source locations for e.g. error
    messages, constructing a SrcSpan without a BufSpan.
    -}

    instance ToJson SrcSpan where
      json :: SrcSpan -> JsonDoc
    json (UnhelpfulSpan {} ) = JsonDoc
    JSNull --JSObject [( "type", "unhelpful")]
      json (RealSrcSpan RealSrcSpan
    rss Maybe BufSpan
    _) = RealSrcSpan -> JsonDoc
    forall a. ToJson a => a -> JsonDoc
    json RealSrcSpan
    rss

    instance ToJson RealSrcSpan where
      json :: RealSrcSpan -> JsonDoc
    json (RealSrcSpan'{Int
    FastString
    srcSpanFile :: RealSrcSpan -> FastString
    srcSpanSLine :: RealSrcSpan -> Int
    srcSpanSCol :: RealSrcSpan -> Int
    srcSpanELine :: RealSrcSpan -> Int
    srcSpanECol :: RealSrcSpan -> Int
    srcSpanFile :: FastString
    srcSpanSLine :: Int
    srcSpanSCol :: Int
    srcSpanELine :: Int
    srcSpanECol :: Int
    ..}) = [(String, JsonDoc)] -> JsonDoc
    JSObject [ (String
    "file", String -> JsonDoc
    JSString (FastString -> String
    unpackFS FastString
    srcSpanFile)),
                                           (String
    "start", JsonDoc
    start),
                                           (String
    "end", JsonDoc
    end)
                                         ]
        where start :: JsonDoc
    start = [(String, JsonDoc)] -> JsonDoc
    JSObject [ (String
    "line", Int -> JsonDoc
    JSInt Int
    srcSpanSLine),
                                 (String
    "column", Int -> JsonDoc
    JSInt Int
    srcSpanSCol) ]
              end :: JsonDoc
    end = [(String, JsonDoc)] -> JsonDoc
    JSObject [ (String
    "line", Int -> JsonDoc
    JSInt Int
    srcSpanELine),
                               (String
    "column", Int -> JsonDoc
    JSInt Int
    srcSpanECol) ]

    instance NFData SrcSpan where
      rnf :: SrcSpan -> ()
    rnf SrcSpan
    x = SrcSpan
    x SrcSpan -> () -> ()
    forall a b. a -> b -> b
    `seq` ()

    getBufSpan :: SrcSpan -> Strict.Maybe BufSpan
    getBufSpan :: SrcSpan -> Maybe BufSpan
    getBufSpan (RealSrcSpan RealSrcSpan
    _ Maybe BufSpan
    mbspan) = Maybe BufSpan
    mbspan
    getBufSpan (UnhelpfulSpan UnhelpfulSpanReason
    _) = Maybe BufSpan
    forall a. Maybe a
    Strict.Nothing

    -- | Built-in "bad" 'SrcSpan's for common sources of location uncertainty
    noSrcSpan, generatedSrcSpan, wiredInSrcSpan, interactiveSrcSpan :: SrcSpan
    noSrcSpan :: SrcSpan
    noSrcSpan          = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan UnhelpfulSpanReason
    UnhelpfulNoLocationInfo
    wiredInSrcSpan :: SrcSpan
    wiredInSrcSpan     = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan UnhelpfulSpanReason
    UnhelpfulWiredIn
    interactiveSrcSpan :: SrcSpan
    interactiveSrcSpan = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan UnhelpfulSpanReason
    UnhelpfulInteractive
    generatedSrcSpan :: SrcSpan
    generatedSrcSpan   = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan UnhelpfulSpanReason
    UnhelpfulGenerated

    isGeneratedSrcSpan :: SrcSpan -> Bool
    isGeneratedSrcSpan :: SrcSpan -> Bool
    isGeneratedSrcSpan (UnhelpfulSpan UnhelpfulSpanReason
    UnhelpfulGenerated) = Bool
    True
    isGeneratedSrcSpan SrcSpan
    _                                  = Bool
    False

    isNoSrcSpan :: SrcSpan -> Bool
    isNoSrcSpan :: SrcSpan -> Bool
    isNoSrcSpan (UnhelpfulSpan UnhelpfulSpanReason
    UnhelpfulNoLocationInfo) = Bool
    True
    isNoSrcSpan SrcSpan
    _                                       = Bool
    False

    -- | Create a "bad" 'SrcSpan' that has not location information
    mkGeneralSrcSpan :: FastString -> SrcSpan
    mkGeneralSrcSpan :: FastString -> SrcSpan
    mkGeneralSrcSpan = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan (UnhelpfulSpanReason -> SrcSpan)
    -> (FastString -> UnhelpfulSpanReason) -> FastString -> SrcSpan
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . FastString -> UnhelpfulSpanReason
    UnhelpfulOther

    -- | Create a 'SrcSpan' corresponding to a single point
    srcLocSpan :: SrcLoc -> SrcSpan
    srcLocSpan :: SrcLoc -> SrcSpan
    srcLocSpan (UnhelpfulLoc FastString
    str) = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan (FastString -> UnhelpfulSpanReason
    UnhelpfulOther FastString
    str)
    srcLocSpan (RealSrcLoc RealSrcLoc
    l Maybe BufPos
    mb) = RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan (RealSrcLoc -> RealSrcSpan
    realSrcLocSpan RealSrcLoc
    l) ((BufPos -> BufSpan) -> Maybe BufPos -> Maybe BufSpan
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\BufPos
    b -> BufPos -> BufPos -> BufSpan
    BufSpan BufPos
    b BufPos
    b) Maybe BufPos
    mb)

    realSrcLocSpan :: RealSrcLoc -> RealSrcSpan
    realSrcLocSpan :: RealSrcLoc -> RealSrcSpan
    realSrcLocSpan (SrcLoc (LexicalFastString FastString
    file) Int
    line Int
    col) = FastString -> Int -> Int -> Int -> Int -> RealSrcSpan
    RealSrcSpan' FastString
    file Int
    line Int
    col Int
    line Int
    col

    -- | Create a 'SrcSpan' between two points in a file
    mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan
    mkRealSrcSpan :: RealSrcLoc -> RealSrcLoc -> RealSrcSpan
    mkRealSrcSpan RealSrcLoc
    loc1 RealSrcLoc
    loc2 = FastString -> Int -> Int -> Int -> Int -> RealSrcSpan
    RealSrcSpan' FastString
    file Int
    line1 Int
    col1 Int
    line2 Int
    col2
      where
            line1 :: Int
    line1 = RealSrcLoc -> Int
    srcLocLine RealSrcLoc
    loc1
            line2 :: Int
    line2 = RealSrcLoc -> Int
    srcLocLine RealSrcLoc
    loc2
            col1 :: Int
    col1 = RealSrcLoc -> Int
    srcLocCol RealSrcLoc
    loc1
            col2 :: Int
    col2 = RealSrcLoc -> Int
    srcLocCol RealSrcLoc
    loc2
            file :: FastString
    file = RealSrcLoc -> FastString
    srcLocFile RealSrcLoc
    loc1

    -- | 'True' if the span is known to straddle only one line.
    isOneLineRealSpan :: RealSrcSpan -> Bool
    isOneLineRealSpan :: RealSrcSpan -> Bool
    isOneLineRealSpan (RealSrcSpan' FastString
    _ Int
    line1 Int
    _ Int
    line2 Int
    _)
      = Int
    line1 Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    line2

    -- | 'True' if the span is a single point
    isPointRealSpan :: RealSrcSpan -> Bool
    isPointRealSpan :: RealSrcSpan -> Bool
    isPointRealSpan (RealSrcSpan' FastString
    _ Int
    line1 Int
    col1 Int
    line2 Int
    col2)
      = Int
    line1 Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    line2 Bool -> Bool -> Bool
    && Int
    col1 Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    col2

    -- | Create a 'SrcSpan' between two points in a file
    mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
    mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
    mkSrcSpan (UnhelpfulLoc FastString
    str) SrcLoc
    _ = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan (FastString -> UnhelpfulSpanReason
    UnhelpfulOther FastString
    str)
    mkSrcSpan SrcLoc
    _ (UnhelpfulLoc FastString
    str) = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan (FastString -> UnhelpfulSpanReason
    UnhelpfulOther FastString
    str)
    mkSrcSpan (RealSrcLoc RealSrcLoc
    loc1 Maybe BufPos
    mbpos1) (RealSrcLoc RealSrcLoc
    loc2 Maybe BufPos
    mbpos2)
        = RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan (RealSrcLoc -> RealSrcLoc -> RealSrcSpan
    mkRealSrcSpan RealSrcLoc
    loc1 RealSrcLoc
    loc2) ((BufPos -> BufPos -> BufSpan)
    -> Maybe BufPos -> Maybe BufPos -> Maybe BufSpan
    forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 BufPos -> BufPos -> BufSpan
    BufSpan Maybe BufPos
    mbpos1 Maybe BufPos
    mbpos2)

    -- | Combines two 'SrcSpan' into one that spans at least all the characters
    -- within both spans. Returns UnhelpfulSpan if the files differ.
    combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans (UnhelpfulSpan UnhelpfulSpanReason
    _) SrcSpan
    r = SrcSpan
    r -- this seems more useful
    combineSrcSpans SrcSpan
    l (UnhelpfulSpan UnhelpfulSpanReason
    _) = SrcSpan
    l
    combineSrcSpans (RealSrcSpan RealSrcSpan
    span1 Maybe BufSpan
    mbspan1) (RealSrcSpan RealSrcSpan
    span2 Maybe BufSpan
    mbspan2)
      | RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    span1 FastString -> FastString -> Bool
    forall a. Eq a => a -> a -> Bool
    == RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    span2
          = RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan (RealSrcSpan -> RealSrcSpan -> RealSrcSpan
    combineRealSrcSpans RealSrcSpan
    span1 RealSrcSpan
    span2) ((BufSpan -> BufSpan -> BufSpan)
    -> Maybe BufSpan -> Maybe BufSpan -> Maybe BufSpan
    forall a b c. (a -> b -> c) -> Maybe a -> Maybe b -> Maybe c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 BufSpan -> BufSpan -> BufSpan
    combineBufSpans Maybe BufSpan
    mbspan1 Maybe BufSpan
    mbspan2)
      | Bool
    otherwise = UnhelpfulSpanReason -> SrcSpan
    UnhelpfulSpan (UnhelpfulSpanReason -> SrcSpan) -> UnhelpfulSpanReason -> SrcSpan
    forall a b. (a -> b) -> a -> b
    $
          FastString -> UnhelpfulSpanReason
    UnhelpfulOther (String -> FastString
    fsLit String
    "<combineSrcSpans: files differ>")

    -- | Combines two 'SrcSpan' into one that spans at least all the characters
    -- within both spans. Assumes the "file" part is the same in both inputs
    combineRealSrcSpans :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan
    combineRealSrcSpans :: RealSrcSpan -> RealSrcSpan -> RealSrcSpan
    combineRealSrcSpans RealSrcSpan
    span1 RealSrcSpan
    span2
      = FastString -> Int -> Int -> Int -> Int -> RealSrcSpan
    RealSrcSpan' FastString
    file Int
    line_start Int
    col_start Int
    line_end Int
    col_end
      where
        (Int
    line_start, Int
    col_start) = (Int, Int) -> (Int, Int) -> (Int, Int)
    forall a. Ord a => a -> a -> a
    min (RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    span1, RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan
    span1)
                                      (RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    span2, RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan
    span2)
        (Int
    line_end, Int
    col_end)     = (Int, Int) -> (Int, Int) -> (Int, Int)
    forall a. Ord a => a -> a -> a
    max (RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    span1, RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan
    span1)
                                      (RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    span2, RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan
    span2)
        file :: FastString
    file = RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    span1

    combineBufSpans :: BufSpan -> BufSpan -> BufSpan
    combineBufSpans :: BufSpan -> BufSpan -> BufSpan
    combineBufSpans BufSpan
    span1 BufSpan
    span2 = BufPos -> BufPos -> BufSpan
    BufSpan BufPos
    start BufPos
    end
      where
        start :: BufPos
    start = BufPos -> BufPos -> BufPos
    forall a. Ord a => a -> a -> a
    min (BufSpan -> BufPos
    bufSpanStart BufSpan
    span1) (BufSpan -> BufPos
    bufSpanStart BufSpan
    span2)
        end :: BufPos
    end   = BufPos -> BufPos -> BufPos
    forall a. Ord a => a -> a -> a
    max (BufSpan -> BufPos
    bufSpanEnd   BufSpan
    span1) (BufSpan -> BufPos
    bufSpanEnd   BufSpan
    span2)

    -- | Convert a SrcSpan into one that represents only its first character
    srcSpanFirstCharacter :: SrcSpan -> SrcSpan
    srcSpanFirstCharacter :: SrcSpan -> SrcSpan
    srcSpanFirstCharacter l :: SrcSpan
    l@(UnhelpfulSpan {}) = SrcSpan
    l
    srcSpanFirstCharacter (RealSrcSpan RealSrcSpan
    span Maybe BufSpan
    mbspan) =
        RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan (RealSrcLoc -> RealSrcLoc -> RealSrcSpan
    mkRealSrcSpan RealSrcLoc
    loc1 RealSrcLoc
    loc2) ((BufSpan -> BufSpan) -> Maybe BufSpan -> Maybe BufSpan
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap BufSpan -> BufSpan
    mkBufSpan Maybe BufSpan
    mbspan)
      where
        loc1 :: RealSrcLoc
    loc1@(SrcLoc LexicalFastString
    f Int
    l Int
    c) = RealSrcSpan -> RealSrcLoc
    realSrcSpanStart RealSrcSpan
    span
        loc2 :: RealSrcLoc
    loc2 = LexicalFastString -> Int -> Int -> RealSrcLoc
    SrcLoc LexicalFastString
    f Int
    l (Int
    cInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)
        mkBufSpan :: BufSpan -> BufSpan
    mkBufSpan BufSpan
    bspan =
          let bpos1 :: BufPos
    bpos1@(BufPos Int
    i) = BufSpan -> BufPos
    bufSpanStart BufSpan
    bspan
              bpos2 :: BufPos
    bpos2 = Int -> BufPos
    BufPos (Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1)
          in BufPos -> BufPos -> BufSpan
    BufSpan BufPos
    bpos1 BufPos
    bpos2

    {-
    ************************************************************************
    *                                                                      *
    \subsection[SrcSpan-predicates]{Predicates}
    *                                                                      *
    ************************************************************************
    -}

    -- | Test if a 'SrcSpan' is "good", i.e. has precise location information
    isGoodSrcSpan :: SrcSpan -> Bool
    isGoodSrcSpan :: SrcSpan -> Bool
    isGoodSrcSpan (RealSrcSpan RealSrcSpan
    _ Maybe BufSpan
    _) = Bool
    True
    isGoodSrcSpan (UnhelpfulSpan UnhelpfulSpanReason
    _) = Bool
    False

    isOneLineSpan :: SrcSpan -> Bool
    -- ^ True if the span is known to straddle only one line.
    -- For "bad" 'SrcSpan', it returns False
    isOneLineSpan :: SrcSpan -> Bool
    isOneLineSpan (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    _) = RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    s Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    s
    isOneLineSpan (UnhelpfulSpan UnhelpfulSpanReason
    _) = Bool
    False

    isZeroWidthSpan :: SrcSpan -> Bool
    -- ^ True if the span has a width of zero, as returned for "virtual"
    -- semicolons in the lexer.
    -- For "bad" 'SrcSpan', it returns False
    isZeroWidthSpan :: SrcSpan -> Bool
    isZeroWidthSpan (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    _) = RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    s Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    s
                                     Bool -> Bool -> Bool
    && RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan
    s Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan
    s
    isZeroWidthSpan (UnhelpfulSpan UnhelpfulSpanReason
    _) = Bool
    False

    -- | Tests whether the first span "contains" the other span, meaning
    -- that it covers at least as much source code. True where spans are equal.
    containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool
    containsSpan :: RealSrcSpan -> RealSrcSpan -> Bool
    containsSpan RealSrcSpan
    s1 RealSrcSpan
    s2
      = (RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    s1, RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan
    s1)
           (Int, Int) -> (Int, Int) -> Bool
    forall a. Ord a => a -> a -> Bool
    <= (RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    s2, RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan
    s2)
        Bool -> Bool -> Bool
    && (RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    s1, RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan
    s1)
           (Int, Int) -> (Int, Int) -> Bool
    forall a. Ord a => a -> a -> Bool
    >= (RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    s2, RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan
    s2)
        Bool -> Bool -> Bool
    && (RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    s1 FastString -> FastString -> Bool
    forall a. Eq a => a -> a -> Bool
    == RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    s2)
        -- We check file equality last because it is (presumably?) least
        -- likely to fail.
    {-
    %************************************************************************
    %*                                                                      *
    \subsection[SrcSpan-unsafe-access-fns]{Unsafe access functions}
    *                                                                      *
    ************************************************************************
    -}

    srcSpanStartLine :: RealSrcSpan -> Int
    srcSpanEndLine :: RealSrcSpan -> Int
    srcSpanStartCol :: RealSrcSpan -> Int
    srcSpanEndCol :: RealSrcSpan -> Int

    srcSpanStartLine :: RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan'{ srcSpanSLine :: RealSrcSpan -> Int
    srcSpanSLine=Int
    l } = Int
    l
    srcSpanEndLine :: RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan'{ srcSpanELine :: RealSrcSpan -> Int
    srcSpanELine=Int
    l } = Int
    l
    srcSpanStartCol :: RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan'{ srcSpanSCol :: RealSrcSpan -> Int
    srcSpanSCol=Int
    l } = Int
    l
    srcSpanEndCol :: RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan'{ srcSpanECol :: RealSrcSpan -> Int
    srcSpanECol=Int
    c } = Int
    c

    {-
    ************************************************************************
    *                                                                      *
    \subsection[SrcSpan-access-fns]{Access functions}
    *                                                                      *
    ************************************************************************
    -}

    -- | Returns the location at the start of the 'SrcSpan' or a "bad" 'SrcSpan' if that is unavailable
    srcSpanStart :: SrcSpan -> SrcLoc
    srcSpanStart :: SrcSpan -> SrcLoc
    srcSpanStart (UnhelpfulSpan UnhelpfulSpanReason
    r) = FastString -> SrcLoc
    UnhelpfulLoc (UnhelpfulSpanReason -> FastString
    unhelpfulSpanFS UnhelpfulSpanReason
    r)
    srcSpanStart (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    b) = RealSrcLoc -> Maybe BufPos -> SrcLoc
    RealSrcLoc (RealSrcSpan -> RealSrcLoc
    realSrcSpanStart RealSrcSpan
    s) ((BufSpan -> BufPos) -> Maybe BufSpan -> Maybe BufPos
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap BufSpan -> BufPos
    bufSpanStart Maybe BufSpan
    b)

    -- | Returns the location at the end of the 'SrcSpan' or a "bad" 'SrcSpan' if that is unavailable
    srcSpanEnd :: SrcSpan -> SrcLoc
    srcSpanEnd :: SrcSpan -> SrcLoc
    srcSpanEnd (UnhelpfulSpan UnhelpfulSpanReason
    r) = FastString -> SrcLoc
    UnhelpfulLoc (UnhelpfulSpanReason -> FastString
    unhelpfulSpanFS UnhelpfulSpanReason
    r)
    srcSpanEnd (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    b) = RealSrcLoc -> Maybe BufPos -> SrcLoc
    RealSrcLoc (RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd RealSrcSpan
    s) ((BufSpan -> BufPos) -> Maybe BufSpan -> Maybe BufPos
    forall a b. (a -> b) -> Maybe a -> Maybe b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap BufSpan -> BufPos
    bufSpanEnd Maybe BufSpan
    b)

    realSrcSpanStart :: RealSrcSpan -> RealSrcLoc
    realSrcSpanStart :: RealSrcSpan -> RealSrcLoc
    realSrcSpanStart RealSrcSpan
    s = FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc (RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    s)
                                      (RealSrcSpan -> Int
    srcSpanStartLine RealSrcSpan
    s)
                                      (RealSrcSpan -> Int
    srcSpanStartCol RealSrcSpan
    s)

    realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd :: RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd RealSrcSpan
    s = FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc (RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    s)
                                    (RealSrcSpan -> Int
    srcSpanEndLine RealSrcSpan
    s)
                                    (RealSrcSpan -> Int
    srcSpanEndCol RealSrcSpan
    s)

    -- | Obtains the filename for a 'SrcSpan' if it is "good"
    srcSpanFileName_maybe :: SrcSpan -> Maybe FastString
    srcSpanFileName_maybe :: SrcSpan -> Maybe FastString
    srcSpanFileName_maybe (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    _) = FastString -> Maybe FastString
    forall a. a -> Maybe a
    Just (RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    s)
    srcSpanFileName_maybe (UnhelpfulSpan UnhelpfulSpanReason
    _) = Maybe FastString
    forall a. Maybe a
    Nothing

    srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan
    srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan
    srcSpanToRealSrcSpan (RealSrcSpan RealSrcSpan
    ss Maybe BufSpan
    _) = RealSrcSpan -> Maybe RealSrcSpan
    forall a. a -> Maybe a
    Just RealSrcSpan
    ss
    srcSpanToRealSrcSpan SrcSpan
    _ = Maybe RealSrcSpan
    forall a. Maybe a
    Nothing

    {-
    ************************************************************************
    *                                                                      *
    \subsection[SrcSpan-instances]{Instances}
    *                                                                      *
    ************************************************************************
    -}

    -- We want to order RealSrcSpans first by the start point, then by the
    -- end point.
    instance Ord RealSrcSpan where
      compare :: RealSrcSpan -> RealSrcSpan -> Ordering
    compare = (RealSrcLoc -> RealSrcLoc -> Ordering)
    -> (RealSrcSpan -> RealSrcLoc)
    -> RealSrcSpan
    -> RealSrcSpan
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    on RealSrcLoc -> RealSrcLoc -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare RealSrcSpan -> RealSrcLoc
    realSrcSpanStart (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> RealSrcSpan
    -> RealSrcSpan
    -> Ordering
    forall a. Semigroup a => a -> a -> a
    S.<> (RealSrcLoc -> RealSrcLoc -> Ordering)
    -> (RealSrcSpan -> RealSrcLoc)
    -> RealSrcSpan
    -> RealSrcSpan
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    on RealSrcLoc -> RealSrcLoc -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd

    instance Show RealSrcLoc where
      show :: RealSrcLoc -> String
    show (SrcLoc LexicalFastString
    filename Int
    row Int
    col)
          = String
    "SrcLoc " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ LexicalFastString -> String
    forall a. Show a => a -> String
    show LexicalFastString
    filename String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    row String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ Int -> String
    forall a. Show a => a -> String
    show Int
    col

    -- Show is used by GHC.Parser.Lexer, because we derive Show for Token
    instance Show RealSrcSpan where
      show :: RealSrcSpan -> String
    show span :: RealSrcSpan
    span@(RealSrcSpan' FastString
    file Int
    sl Int
    sc Int
    el Int
    ec)
        | RealSrcSpan -> Bool
    isPointRealSpan RealSrcSpan
    span
        = String
    "SrcSpanPoint " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ FastString -> String
    forall a. Show a => a -> String
    show FastString
    file String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    " " ((Int -> String) -> [Int] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map Int -> String
    forall a. Show a => a -> String
    show [Int
    sl,Int
    sc])

        | RealSrcSpan -> Bool
    isOneLineRealSpan RealSrcSpan
    span
        = String
    "SrcSpanOneLine " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ FastString -> String
    forall a. Show a => a -> String
    show FastString
    file String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " "
                            String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    " " ((Int -> String) -> [Int] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map Int -> String
    forall a. Show a => a -> String
    show [Int
    sl,Int
    sc,Int
    ec])

        | Bool
    otherwise
        = String
    "SrcSpanMultiLine " String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ FastString -> String
    forall a. Show a => a -> String
    show FastString
    file String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String
    " "
                              String -> ShowS
    forall a. [a] -> [a] -> [a]
    ++ String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    " " ((Int -> String) -> [Int] -> [String]
    forall a b. (a -> b) -> [a] -> [b]
    map Int -> String
    forall a. Show a => a -> String
    show [Int
    sl,Int
    sc,Int
    el,Int
    ec])

    instance Outputable RealSrcSpan where
        ppr :: RealSrcSpan -> SDoc
    ppr RealSrcSpan
    span = Bool -> RealSrcSpan -> SDoc
    pprUserRealSpan Bool
    True RealSrcSpan
    span

    -- I don't know why there is this style-based difference
    --      = getPprStyle $ \ sty ->
    --        if userStyle sty || debugStyle sty then
    --           text (showUserRealSpan True span)
    --        else
    --           hcat [text "{-# LINE ", int (srcSpanStartLine span), space,
    --                 char '\"', pprFastFilePath $ srcSpanFile span, text " #-}"]

    instance Outputable SrcSpan where
        ppr :: SrcSpan -> SDoc
    ppr SrcSpan
    span = Bool -> SrcSpan -> SDoc
    pprUserSpan Bool
    True SrcSpan
    span

    instance Outputable UnhelpfulSpanReason where
        ppr :: UnhelpfulSpanReason -> SDoc
    ppr = UnhelpfulSpanReason -> SDoc
    pprUnhelpfulSpanReason

    -- I don't know why there is this style-based difference
    --      = getPprStyle $ \ sty ->
    --        if userStyle sty || debugStyle sty then
    --           pprUserSpan True span
    --        else
    --           case span of
    --           UnhelpfulSpan _ -> panic "Outputable UnhelpfulSpan"
    --           RealSrcSpan s -> ppr s

    unhelpfulSpanFS :: UnhelpfulSpanReason -> FastString
    unhelpfulSpanFS :: UnhelpfulSpanReason -> FastString
    unhelpfulSpanFS UnhelpfulSpanReason
    r = case UnhelpfulSpanReason
    r of
      UnhelpfulOther FastString
    s        -> FastString
    s
      UnhelpfulSpanReason
    UnhelpfulNoLocationInfo -> String -> FastString
    fsLit String
    "<no location info>"
      UnhelpfulSpanReason
    UnhelpfulWiredIn        -> String -> FastString
    fsLit String
    "<wired into compiler>"
      UnhelpfulSpanReason
    UnhelpfulInteractive    -> String -> FastString
    fsLit String
    "<interactive>"
      UnhelpfulSpanReason
    UnhelpfulGenerated      -> String -> FastString
    fsLit String
    "<generated>"

    pprUnhelpfulSpanReason :: UnhelpfulSpanReason -> SDoc
    pprUnhelpfulSpanReason :: UnhelpfulSpanReason -> SDoc
    pprUnhelpfulSpanReason UnhelpfulSpanReason
    r = FastString -> SDoc
    forall doc. IsLine doc => FastString -> doc
    ftext (UnhelpfulSpanReason -> FastString
    unhelpfulSpanFS UnhelpfulSpanReason
    r)

    pprUserSpan :: Bool -> SrcSpan -> SDoc
    pprUserSpan :: Bool -> SrcSpan -> SDoc
    pprUserSpan Bool
    _         (UnhelpfulSpan UnhelpfulSpanReason
    r) = UnhelpfulSpanReason -> SDoc
    pprUnhelpfulSpanReason UnhelpfulSpanReason
    r
    pprUserSpan Bool
    show_path (RealSrcSpan RealSrcSpan
    s Maybe BufSpan
    _) = Bool -> RealSrcSpan -> SDoc
    pprUserRealSpan Bool
    show_path RealSrcSpan
    s

    pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc
    pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc
    pprUserRealSpan Bool
    show_path span :: RealSrcSpan
    span@(RealSrcSpan' FastString
    src_path Int
    line Int
    col Int
    _ Int
    _)
      | RealSrcSpan -> Bool
    isPointRealSpan RealSrcSpan
    span
      = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hcat [ Bool -> SDoc -> SDoc
    forall doc. IsOutput doc => Bool -> doc -> doc
    ppWhen Bool
    show_path (FastString -> SDoc
    pprFastFilePath FastString
    src_path SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon)
             , Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    line SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon
             , Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    col ]

    pprUserRealSpan Bool
    show_path span :: RealSrcSpan
    span@(RealSrcSpan' FastString
    src_path Int
    line Int
    scol Int
    _ Int
    ecol)
      | RealSrcSpan -> Bool
    isOneLineRealSpan RealSrcSpan
    span
      = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hcat [ Bool -> SDoc -> SDoc
    forall doc. IsOutput doc => Bool -> doc -> doc
    ppWhen Bool
    show_path (FastString -> SDoc
    pprFastFilePath FastString
    src_path SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon)
             , Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    line SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon
             , Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    scol
             , Bool -> SDoc -> SDoc
    forall doc. IsOutput doc => Bool -> doc -> doc
    ppUnless (Int
    ecol Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    scol Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    1) (Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    '-' SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int (Int
    ecol Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1)) ]
                -- For single-character or point spans, we just
                -- output the starting column number

    pprUserRealSpan Bool
    show_path (RealSrcSpan' FastString
    src_path Int
    sline Int
    scol Int
    eline Int
    ecol)
      = [SDoc] -> SDoc
    forall doc. IsLine doc => [doc] -> doc
    hcat [ Bool -> SDoc -> SDoc
    forall doc. IsOutput doc => Bool -> doc -> doc
    ppWhen Bool
    show_path (FastString -> SDoc
    pprFastFilePath FastString
    src_path SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    colon)
             , SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens (Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    sline SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    comma SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    scol)
             , Char -> SDoc
    forall doc. IsLine doc => Char -> doc
    char Char
    '-'
             , SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    parens (Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    eline SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> SDoc
    forall doc. IsLine doc => doc
    comma SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <> Int -> SDoc
    forall doc. IsLine doc => Int -> doc
    int Int
    ecol') ]
     where
       ecol' :: Int
    ecol' = if Int
    ecol Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    0 then Int
    ecol else Int
    ecol Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    1

    {-
    ************************************************************************
    *                                                                      *
    \subsection[Located]{Attaching SrcSpans to things}
    *                                                                      *
    ************************************************************************
    -}

    -- | We attach SrcSpans to lots of things, so let's have a datatype for it.
    data GenLocated l e = L l e
      deriving (GenLocated l e -> GenLocated l e -> Bool
    (GenLocated l e -> GenLocated l e -> Bool)
    -> (GenLocated l e -> GenLocated l e -> Bool)
    -> Eq (GenLocated l e)
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    forall l e.
    (Eq l, Eq e) =>
    GenLocated l e -> GenLocated l e -> Bool
    $c== :: forall l e.
    (Eq l, Eq e) =>
    GenLocated l e -> GenLocated l e -> Bool
    == :: GenLocated l e -> GenLocated l e -> Bool
    $c/= :: forall l e.
    (Eq l, Eq e) =>
    GenLocated l e -> GenLocated l e -> Bool
    /= :: GenLocated l e -> GenLocated l e -> Bool
    Eq, Eq (GenLocated l e)
    Eq (GenLocated l e) =>
    (GenLocated l e -> GenLocated l e -> Ordering)
    -> (GenLocated l e -> GenLocated l e -> Bool)
    -> (GenLocated l e -> GenLocated l e -> Bool)
    -> (GenLocated l e -> GenLocated l e -> Bool)
    -> (GenLocated l e -> GenLocated l e -> Bool)
    -> (GenLocated l e -> GenLocated l e -> GenLocated l e)
    -> (GenLocated l e -> GenLocated l e -> GenLocated l e)
    -> Ord (GenLocated l e)
    GenLocated l e -> GenLocated l e -> Bool
    GenLocated l e -> GenLocated l e -> Ordering
    GenLocated l e -> GenLocated l e -> GenLocated l e
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    forall l e. (Ord l, Ord e) => Eq (GenLocated l e)
    forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> Bool
    forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> Ordering
    forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> GenLocated l e
    $ccompare :: forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> Ordering
    compare :: GenLocated l e -> GenLocated l e -> Ordering
    $c< :: forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> Bool
    < :: GenLocated l e -> GenLocated l e -> Bool
    $c<= :: forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> Bool
    <= :: GenLocated l e -> GenLocated l e -> Bool
    $c> :: forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> Bool
    > :: GenLocated l e -> GenLocated l e -> Bool
    $c>= :: forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> Bool
    >= :: GenLocated l e -> GenLocated l e -> Bool
    $cmax :: forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> GenLocated l e
    max :: GenLocated l e -> GenLocated l e -> GenLocated l e
    $cmin :: forall l e.
    (Ord l, Ord e) =>
    GenLocated l e -> GenLocated l e -> GenLocated l e
    min :: GenLocated l e -> GenLocated l e -> GenLocated l e
    Ord, Int -> GenLocated l e -> ShowS
    [GenLocated l e] -> ShowS
    GenLocated l e -> String
    (Int -> GenLocated l e -> ShowS)
    -> (GenLocated l e -> String)
    -> ([GenLocated l e] -> ShowS)
    -> Show (GenLocated l e)
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    forall l e. (Show l, Show e) => Int -> GenLocated l e -> ShowS
    forall l e. (Show l, Show e) => [GenLocated l e] -> ShowS
    forall l e. (Show l, Show e) => GenLocated l e -> String
    $cshowsPrec :: forall l e. (Show l, Show e) => Int -> GenLocated l e -> ShowS
    showsPrec :: Int -> GenLocated l e -> ShowS
    $cshow :: forall l e. (Show l, Show e) => GenLocated l e -> String
    show :: GenLocated l e -> String
    $cshowList :: forall l e. (Show l, Show e) => [GenLocated l e] -> ShowS
    showList :: [GenLocated l e] -> ShowS
    Show, Typeable (GenLocated l e)
    Typeable (GenLocated l e) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (GenLocated l e))
    -> (GenLocated l e -> Constr)
    -> (GenLocated l e -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (GenLocated l e)))
    -> ((forall b. Data b => b -> b)
        -> GenLocated l e -> GenLocated l e)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> GenLocated l e -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> GenLocated l e -> m (GenLocated l e))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> GenLocated l e -> m (GenLocated l e))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> GenLocated l e -> m (GenLocated l e))
    -> Data (GenLocated l e)
    GenLocated l e -> Constr
    GenLocated l e -> DataType
    (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u
    forall u. (forall d. Data d => d -> u) -> GenLocated l e -> [u]
    forall l e. (Data l, Data e) => Typeable (GenLocated l e)
    forall l e. (Data l, Data e) => GenLocated l e -> Constr
    forall l e. (Data l, Data e) => GenLocated l e -> DataType
    forall l e.
    (Data l, Data e) =>
    (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e
    forall l e u.
    (Data l, Data e) =>
    Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u
    forall l e u.
    (Data l, Data e) =>
    (forall d. Data d => d -> u) -> GenLocated l e -> [u]
    forall l e r r'.
    (Data l, Data e) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    forall l e r r'.
    (Data l, Data e) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    forall l e (m :: * -> *).
    (Data l, Data e, Monad m) =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    forall l e (m :: * -> *).
    (Data l, Data e, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    forall l e (c :: * -> *).
    (Data l, Data e) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GenLocated l e)
    forall l e (c :: * -> *).
    (Data l, Data e) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e)
    forall l e (t :: * -> *) (c :: * -> *).
    (Data l, Data e, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e))
    forall l e (t :: * -> * -> *) (c :: * -> *).
    (Data l, Data e, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenLocated l e))
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GenLocated l e)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenLocated l e))
    $cgfoldl :: forall l e (c :: * -> *).
    (Data l, Data e) =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> GenLocated l e -> c (GenLocated l e)
    $cgunfold :: forall l e (c :: * -> *).
    (Data l, Data e) =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GenLocated l e)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (GenLocated l e)
    $ctoConstr :: forall l e. (Data l, Data e) => GenLocated l e -> Constr
    toConstr :: GenLocated l e -> Constr
    $cdataTypeOf :: forall l e. (Data l, Data e) => GenLocated l e -> DataType
    dataTypeOf :: GenLocated l e -> DataType
    $cdataCast1 :: forall l e (t :: * -> *) (c :: * -> *).
    (Data l, Data e, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (GenLocated l e))
    $cdataCast2 :: forall l e (t :: * -> * -> *) (c :: * -> *).
    (Data l, Data e, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenLocated l e))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenLocated l e))
    $cgmapT :: forall l e.
    (Data l, Data e) =>
    (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e
    gmapT :: (forall b. Data b => b -> b) -> GenLocated l e -> GenLocated l e
    $cgmapQl :: forall l e r r'.
    (Data l, Data e) =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    $cgmapQr :: forall l e r r'.
    (Data l, Data e) =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> GenLocated l e -> r
    $cgmapQ :: forall l e u.
    (Data l, Data e) =>
    (forall d. Data d => d -> u) -> GenLocated l e -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> GenLocated l e -> [u]
    $cgmapQi :: forall l e u.
    (Data l, Data e) =>
    Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> GenLocated l e -> u
    $cgmapM :: forall l e (m :: * -> *).
    (Data l, Data e, Monad m) =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    $cgmapMp :: forall l e (m :: * -> *).
    (Data l, Data e, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    $cgmapMo :: forall l e (m :: * -> *).
    (Data l, Data e, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenLocated l e -> m (GenLocated l e)
    Data, (forall a b. (a -> b) -> GenLocated l a -> GenLocated l b)
    -> (forall a b. a -> GenLocated l b -> GenLocated l a)
    -> Functor (GenLocated l)
    forall a b. a -> GenLocated l b -> GenLocated l a
    forall a b. (a -> b) -> GenLocated l a -> GenLocated l b
    forall l a b. a -> GenLocated l b -> GenLocated l a
    forall l a b. (a -> b) -> GenLocated l a -> GenLocated l b
    forall (f :: * -> *).
    (forall a b. (a -> b) -> f a -> f b)
    -> (forall a b. a -> f b -> f a) -> Functor f
    $cfmap :: forall l a b. (a -> b) -> GenLocated l a -> GenLocated l b
    fmap :: forall a b. (a -> b) -> GenLocated l a -> GenLocated l b
    $c<$ :: forall l a b. a -> GenLocated l b -> GenLocated l a
    <$ :: forall a b. a -> GenLocated l b -> GenLocated l a
    Functor, (forall m. Monoid m => GenLocated l m -> m)
    -> (forall m a. Monoid m => (a -> m) -> GenLocated l a -> m)
    -> (forall m a. Monoid m => (a -> m) -> GenLocated l a -> m)
    -> (forall a b. (a -> b -> b) -> b -> GenLocated l a -> b)
    -> (forall a b. (a -> b -> b) -> b -> GenLocated l a -> b)
    -> (forall b a. (b -> a -> b) -> b -> GenLocated l a -> b)
    -> (forall b a. (b -> a -> b) -> b -> GenLocated l a -> b)
    -> (forall a. (a -> a -> a) -> GenLocated l a -> a)
    -> (forall a. (a -> a -> a) -> GenLocated l a -> a)
    -> (forall a. GenLocated l a -> [a])
    -> (forall a. GenLocated l a -> Bool)
    -> (forall a. GenLocated l a -> Int)
    -> (forall a. Eq a => a -> GenLocated l a -> Bool)
    -> (forall a. Ord a => GenLocated l a -> a)
    -> (forall a. Ord a => GenLocated l a -> a)
    -> (forall a. Num a => GenLocated l a -> a)
    -> (forall a. Num a => GenLocated l a -> a)
    -> Foldable (GenLocated l)
    forall a. Eq a => a -> GenLocated l a -> Bool
    forall a. Num a => GenLocated l a -> a
    forall a. Ord a => GenLocated l a -> a
    forall m. Monoid m => GenLocated l m -> m
    forall a. GenLocated l a -> Bool
    forall a. GenLocated l a -> Int
    forall a. GenLocated l a -> [a]
    forall a. (a -> a -> a) -> GenLocated l a -> a
    forall l a. Eq a => a -> GenLocated l a -> Bool
    forall l a. Num a => GenLocated l a -> a
    forall l a. Ord a => GenLocated l a -> a
    forall l m. Monoid m => GenLocated l m -> m
    forall m a. Monoid m => (a -> m) -> GenLocated l a -> m
    forall l a. GenLocated l a -> Bool
    forall l a. GenLocated l a -> Int
    forall l a. GenLocated l a -> [a]
    forall b a. (b -> a -> b) -> b -> GenLocated l a -> b
    forall a b. (a -> b -> b) -> b -> GenLocated l a -> b
    forall l a. (a -> a -> a) -> GenLocated l a -> a
    forall l m a. Monoid m => (a -> m) -> GenLocated l a -> m
    forall l b a. (b -> a -> b) -> b -> GenLocated l a -> b
    forall l a b. (a -> b -> b) -> b -> GenLocated l a -> b
    forall (t :: * -> *).
    (forall m. Monoid m => t m -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall m a. Monoid m => (a -> m) -> t a -> m)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall a b. (a -> b -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall b a. (b -> a -> b) -> b -> t a -> b)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. (a -> a -> a) -> t a -> a)
    -> (forall a. t a -> [a])
    -> (forall a. t a -> Bool)
    -> (forall a. t a -> Int)
    -> (forall a. Eq a => a -> t a -> Bool)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Ord a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> (forall a. Num a => t a -> a)
    -> Foldable t
    $cfold :: forall l m. Monoid m => GenLocated l m -> m
    fold :: forall m. Monoid m => GenLocated l m -> m
    $cfoldMap :: forall l m a. Monoid m => (a -> m) -> GenLocated l a -> m
    foldMap :: forall m a. Monoid m => (a -> m) -> GenLocated l a -> m
    $cfoldMap' :: forall l m a. Monoid m => (a -> m) -> GenLocated l a -> m
    foldMap' :: forall m a. Monoid m => (a -> m) -> GenLocated l a -> m
    $cfoldr :: forall l a b. (a -> b -> b) -> b -> GenLocated l a -> b
    foldr :: forall a b. (a -> b -> b) -> b -> GenLocated l a -> b
    $cfoldr' :: forall l a b. (a -> b -> b) -> b -> GenLocated l a -> b
    foldr' :: forall a b. (a -> b -> b) -> b -> GenLocated l a -> b
    $cfoldl :: forall l b a. (b -> a -> b) -> b -> GenLocated l a -> b
    foldl :: forall b a. (b -> a -> b) -> b -> GenLocated l a -> b
    $cfoldl' :: forall l b a. (b -> a -> b) -> b -> GenLocated l a -> b
    foldl' :: forall b a. (b -> a -> b) -> b -> GenLocated l a -> b
    $cfoldr1 :: forall l a. (a -> a -> a) -> GenLocated l a -> a
    foldr1 :: forall a. (a -> a -> a) -> GenLocated l a -> a
    $cfoldl1 :: forall l a. (a -> a -> a) -> GenLocated l a -> a
    foldl1 :: forall a. (a -> a -> a) -> GenLocated l a -> a
    $ctoList :: forall l a. GenLocated l a -> [a]
    toList :: forall a. GenLocated l a -> [a]
    $cnull :: forall l a. GenLocated l a -> Bool
    null :: forall a. GenLocated l a -> Bool
    $clength :: forall l a. GenLocated l a -> Int
    length :: forall a. GenLocated l a -> Int
    $celem :: forall l a. Eq a => a -> GenLocated l a -> Bool
    elem :: forall a. Eq a => a -> GenLocated l a -> Bool
    $cmaximum :: forall l a. Ord a => GenLocated l a -> a
    maximum :: forall a. Ord a => GenLocated l a -> a
    $cminimum :: forall l a. Ord a => GenLocated l a -> a
    minimum :: forall a. Ord a => GenLocated l a -> a
    $csum :: forall l a. Num a => GenLocated l a -> a
    sum :: forall a. Num a => GenLocated l a -> a
    $cproduct :: forall l a. Num a => GenLocated l a -> a
    product :: forall a. Num a => GenLocated l a -> a
    Foldable, Functor (GenLocated l)
    Foldable (GenLocated l)
    (Functor (GenLocated l), Foldable (GenLocated l)) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> GenLocated l a -> f (GenLocated l b))
    -> (forall (f :: * -> *) a.
        Applicative f =>
        GenLocated l (f a) -> f (GenLocated l a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> GenLocated l a -> m (GenLocated l b))
    -> (forall (m :: * -> *) a.
        Monad m =>
        GenLocated l (m a) -> m (GenLocated l a))
    -> Traversable (GenLocated l)
    forall l. Functor (GenLocated l)
    forall l. Foldable (GenLocated l)
    forall l (m :: * -> *) a.
    Monad m =>
    GenLocated l (m a) -> m (GenLocated l a)
    forall l (f :: * -> *) a.
    Applicative f =>
    GenLocated l (f a) -> f (GenLocated l a)
    forall l (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenLocated l a -> m (GenLocated l b)
    forall l (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GenLocated l a -> f (GenLocated l b)
    forall (t :: * -> *).
    (Functor t, Foldable t) =>
    (forall (f :: * -> *) a b.
     Applicative f =>
     (a -> f b) -> t a -> f (t b))
    -> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
    -> (forall (m :: * -> *) a b.
        Monad m =>
        (a -> m b) -> t a -> m (t b))
    -> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
    -> Traversable t
    forall (m :: * -> *) a.
    Monad m =>
    GenLocated l (m a) -> m (GenLocated l a)
    forall (f :: * -> *) a.
    Applicative f =>
    GenLocated l (f a) -> f (GenLocated l a)
    forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenLocated l a -> m (GenLocated l b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GenLocated l a -> f (GenLocated l b)
    $ctraverse :: forall l (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GenLocated l a -> f (GenLocated l b)
    traverse :: forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> GenLocated l a -> f (GenLocated l b)
    $csequenceA :: forall l (f :: * -> *) a.
    Applicative f =>
    GenLocated l (f a) -> f (GenLocated l a)
    sequenceA :: forall (f :: * -> *) a.
    Applicative f =>
    GenLocated l (f a) -> f (GenLocated l a)
    $cmapM :: forall l (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenLocated l a -> m (GenLocated l b)
    mapM :: forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> GenLocated l a -> m (GenLocated l b)
    $csequence :: forall l (m :: * -> *) a.
    Monad m =>
    GenLocated l (m a) -> m (GenLocated l a)
    sequence :: forall (m :: * -> *) a.
    Monad m =>
    GenLocated l (m a) -> m (GenLocated l a)
    Traversable)
    instance (NFData l, NFData e) => NFData (GenLocated l e) where
      rnf :: GenLocated l e -> ()
    rnf (L l
    l e
    e) = l -> ()
    forall a. NFData a => a -> ()
    rnf l
    l () -> () -> ()
    forall a b. a -> b -> b
    `seq` e -> ()
    forall a. NFData a => a -> ()
    rnf e
    e

    type Located = GenLocated SrcSpan
    type RealLocated = GenLocated RealSrcSpan

    unLoc :: GenLocated l e -> e
    unLoc :: forall l e. GenLocated l e -> e
    unLoc (L l
    _ e
    e) = e
    e

    getLoc :: GenLocated l e -> l
    getLoc :: forall l e. GenLocated l e -> l
    getLoc (L l
    l e
    _) = l
    l

    noLoc :: e -> Located e
    noLoc :: forall e. e -> Located e
    noLoc e
    e = SrcSpan -> e -> GenLocated SrcSpan e
    forall l e. l -> e -> GenLocated l e
    L SrcSpan
    noSrcSpan e
    e

    mkGeneralLocated :: String -> e -> Located e
    mkGeneralLocated :: forall e. String -> e -> Located e
    mkGeneralLocated String
    s e
    e = SrcSpan -> e -> GenLocated SrcSpan e
    forall l e. l -> e -> GenLocated l e
    L (FastString -> SrcSpan
    mkGeneralSrcSpan (String -> FastString
    fsLit String
    s)) e
    e

    combineLocs :: Located a -> Located b -> SrcSpan
    combineLocs :: forall a b. Located a -> Located b -> SrcSpan
    combineLocs Located a
    a Located b
    b = SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans (Located a -> SrcSpan
    forall l e. GenLocated l e -> l
    getLoc Located a
    a) (Located b -> SrcSpan
    forall l e. GenLocated l e -> l
    getLoc Located b
    b)

    -- | Combine locations from two 'Located' things and add them to a third thing
    addCLoc :: Located a -> Located b -> c -> Located c
    addCLoc :: forall a b c. Located a -> Located b -> c -> Located c
    addCLoc Located a
    a Located b
    b c
    c = SrcSpan -> c -> GenLocated SrcSpan c
    forall l e. l -> e -> GenLocated l e
    L (SrcSpan -> SrcSpan -> SrcSpan
    combineSrcSpans (Located a -> SrcSpan
    forall l e. GenLocated l e -> l
    getLoc Located a
    a) (Located b -> SrcSpan
    forall l e. GenLocated l e -> l
    getLoc Located b
    b)) c
    c

    -- not clear whether to add a general Eq instance, but this is useful sometimes:

    -- | Tests whether the two located things are equal
    eqLocated :: Eq a => GenLocated l a -> GenLocated l a -> Bool
    eqLocated :: forall a l. Eq a => GenLocated l a -> GenLocated l a -> Bool
    eqLocated GenLocated l a
    a GenLocated l a
    b = GenLocated l a -> a
    forall l e. GenLocated l e -> e
    unLoc GenLocated l a
    a a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    == GenLocated l a -> a
    forall l e. GenLocated l e -> e
    unLoc GenLocated l a
    b

    -- not clear whether to add a general Ord instance, but this is useful sometimes:

    -- | Tests the ordering of the two located things
    cmpLocated :: Ord a => GenLocated l a -> GenLocated l a -> Ordering
    cmpLocated :: forall a l. Ord a => GenLocated l a -> GenLocated l a -> Ordering
    cmpLocated GenLocated l a
    a GenLocated l a
    b = GenLocated l a -> a
    forall l e. GenLocated l e -> e
    unLoc GenLocated l a
    a a -> a -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` GenLocated l a -> a
    forall l e. GenLocated l e -> e
    unLoc GenLocated l a
    b

    -- | Compare the 'BufSpan' of two located things.
    --
    -- Precondition: both operands have an associated 'BufSpan'.
    cmpBufSpan :: HasDebugCallStack => Located a -> Located a -> Ordering
    cmpBufSpan :: forall a. HasDebugCallStack => Located a -> Located a -> Ordering
    cmpBufSpan (L SrcSpan
    l1 a
    _) (L SrcSpan
    l2  a
    _)
      | Strict.Just BufSpan
    a <- SrcSpan -> Maybe BufSpan
    getBufSpan SrcSpan
    l1
      , Strict.Just BufSpan
    b <- SrcSpan -> Maybe BufSpan
    getBufSpan SrcSpan
    l2
      = BufSpan -> BufSpan -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare BufSpan
    a BufSpan
    b

      | Bool
    otherwise = String -> Ordering
    forall a. HasCallStack => String -> a
    panic String
    "cmpBufSpan: no BufSpan"

    instance (Outputable e) => Outputable (Located e) where
      ppr :: Located e -> SDoc
    ppr (L SrcSpan
    l e
    e) = -- GenLocated:
                    -- Print spans without the file name etc
                    SDoc -> SDoc
    forall doc. IsOutput doc => doc -> doc
    whenPprDebug (SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (Bool -> SrcSpan -> SDoc
    pprUserSpan Bool
    False SrcSpan
    l))
                 SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ e -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr e
    e
    instance (Outputable e) => Outputable (GenLocated RealSrcSpan e) where
      ppr :: GenLocated RealSrcSpan e -> SDoc
    ppr (L RealSrcSpan
    l e
    e) = -- GenLocated:
                    -- Print spans without the file name etc
                    SDoc -> SDoc
    forall doc. IsOutput doc => doc -> doc
    whenPprDebug (SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (Bool -> SrcSpan -> SDoc
    pprUserSpan Bool
    False (RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan RealSrcSpan
    l Maybe BufSpan
    forall a. Maybe a
    Strict.Nothing)))
                 SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ e -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr e
    e

    pprLocated :: (Outputable l, Outputable e) => GenLocated l e -> SDoc
    pprLocated :: forall l e. (Outputable l, Outputable e) => GenLocated l e -> SDoc
    pprLocated (L l
    l e
    e) =
                    -- Print spans without the file name etc
                    SDoc -> SDoc
    forall doc. IsOutput doc => doc -> doc
    whenPprDebug (SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (l -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr l
    l))
                 SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ e -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr e
    e

    -- | Always prints the location, even without -dppr-debug
    pprLocatedAlways :: (Outputable l, Outputable e) => GenLocated l e -> SDoc
    pprLocatedAlways :: forall l e. (Outputable l, Outputable e) => GenLocated l e -> SDoc
    pprLocatedAlways (L l
    l e
    e) =
         SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc
    braces (l -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr l
    l)
      SDoc -> SDoc -> SDoc
    forall doc. IsDoc doc => doc -> doc -> doc
    $$ e -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr e
    e

    {-
    ************************************************************************
    *                                                                      *
    \subsection{Ordering SrcSpans for InteractiveUI}
    *                                                                      *
    ************************************************************************
    -}

    -- | Strategies for ordering 'SrcSpan's
    leftmost_smallest, leftmost_largest, rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering
    rightmost_smallest :: SrcSpan -> SrcSpan -> Ordering
    rightmost_smallest = (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> SrcSpan -> SrcSpan -> Ordering
    compareSrcSpanBy ((RealSrcSpan -> RealSrcSpan -> Ordering)
    -> RealSrcSpan -> RealSrcSpan -> Ordering
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip RealSrcSpan -> RealSrcSpan -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare)
    leftmost_smallest :: SrcSpan -> SrcSpan -> Ordering
    leftmost_smallest = (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> SrcSpan -> SrcSpan -> Ordering
    compareSrcSpanBy RealSrcSpan -> RealSrcSpan -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare
    leftmost_largest :: SrcSpan -> SrcSpan -> Ordering
    leftmost_largest = (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> SrcSpan -> SrcSpan -> Ordering
    compareSrcSpanBy ((RealSrcSpan -> RealSrcSpan -> Ordering)
     -> SrcSpan -> SrcSpan -> Ordering)
    -> (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> SrcSpan
    -> SrcSpan
    -> Ordering
    forall a b. (a -> b) -> a -> b
    $
      (RealSrcLoc -> RealSrcLoc -> Ordering)
    -> (RealSrcSpan -> RealSrcLoc)
    -> RealSrcSpan
    -> RealSrcSpan
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    on RealSrcLoc -> RealSrcLoc -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare RealSrcSpan -> RealSrcLoc
    realSrcSpanStart (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> RealSrcSpan
    -> RealSrcSpan
    -> Ordering
    forall a. Semigroup a => a -> a -> a
    S.<> (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> RealSrcSpan -> RealSrcSpan -> Ordering
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((RealSrcLoc -> RealSrcLoc -> Ordering)
    -> (RealSrcSpan -> RealSrcLoc)
    -> RealSrcSpan
    -> RealSrcSpan
    -> Ordering
    forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
    on RealSrcLoc -> RealSrcLoc -> Ordering
    forall a. Ord a => a -> a -> Ordering
    compare RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd)

    compareSrcSpanBy :: (RealSrcSpan -> RealSrcSpan -> Ordering) -> SrcSpan -> SrcSpan -> Ordering
    compareSrcSpanBy :: (RealSrcSpan -> RealSrcSpan -> Ordering)
    -> SrcSpan -> SrcSpan -> Ordering
    compareSrcSpanBy RealSrcSpan -> RealSrcSpan -> Ordering
    cmp (RealSrcSpan RealSrcSpan
    a Maybe BufSpan
    _) (RealSrcSpan RealSrcSpan
    b Maybe BufSpan
    _) = RealSrcSpan -> RealSrcSpan -> Ordering
    cmp RealSrcSpan
    a RealSrcSpan
    b
    compareSrcSpanBy RealSrcSpan -> RealSrcSpan -> Ordering
    _   (RealSrcSpan RealSrcSpan
    _ Maybe BufSpan
    _) (UnhelpfulSpan UnhelpfulSpanReason
    _) = Ordering
    LT
    compareSrcSpanBy RealSrcSpan -> RealSrcSpan -> Ordering
    _   (UnhelpfulSpan UnhelpfulSpanReason
    _) (RealSrcSpan RealSrcSpan
    _ Maybe BufSpan
    _) = Ordering
    GT
    compareSrcSpanBy RealSrcSpan -> RealSrcSpan -> Ordering
    _   (UnhelpfulSpan UnhelpfulSpanReason
    _) (UnhelpfulSpan UnhelpfulSpanReason
    _) = Ordering
    EQ

    -- | Determines whether a span encloses a given line and column index
    spans :: SrcSpan -> (Int, Int) -> Bool
    spans :: SrcSpan -> (Int, Int) -> Bool
    spans (UnhelpfulSpan UnhelpfulSpanReason
    _) (Int, Int)
    _ = String -> Bool
    forall a. HasCallStack => String -> a
    panic String
    "spans UnhelpfulSpan"
    spans (RealSrcSpan RealSrcSpan
    span Maybe BufSpan
    _) (Int
    l,Int
    c) = RealSrcSpan -> RealSrcLoc
    realSrcSpanStart RealSrcSpan
    span RealSrcLoc -> RealSrcLoc -> Bool
    forall a. Ord a => a -> a -> Bool
    <= RealSrcLoc
    loc Bool -> Bool -> Bool
    && RealSrcLoc
    loc RealSrcLoc -> RealSrcLoc -> Bool
    forall a. Ord a => a -> a -> Bool
    <= RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd RealSrcSpan
    span
       where loc :: RealSrcLoc
    loc = FastString -> Int -> Int -> RealSrcLoc
    mkRealSrcLoc (RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    span) Int
    l Int
    c

    -- | Determines whether a span is enclosed by another one
    isSubspanOf :: SrcSpan -- ^ The span that may be enclosed by the other
                -> SrcSpan -- ^ The span it may be enclosed by
                -> Bool
    isSubspanOf :: SrcSpan -> SrcSpan -> Bool
    isSubspanOf (RealSrcSpan RealSrcSpan
    src Maybe BufSpan
    _) (RealSrcSpan RealSrcSpan
    parent Maybe BufSpan
    _) = RealSrcSpan -> RealSrcSpan -> Bool
    isRealSubspanOf RealSrcSpan
    src RealSrcSpan
    parent
    isSubspanOf SrcSpan
    _ SrcSpan
    _ = Bool
    False

    -- | Determines whether a span is enclosed by another one
    isRealSubspanOf :: RealSrcSpan -- ^ The span that may be enclosed by the other
                    -> RealSrcSpan -- ^ The span it may be enclosed by
                    -> Bool
    isRealSubspanOf :: RealSrcSpan -> RealSrcSpan -> Bool
    isRealSubspanOf RealSrcSpan
    src RealSrcSpan
    parent
        | RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    parent FastString -> FastString -> Bool
    forall a. Eq a => a -> a -> Bool
    /= RealSrcSpan -> FastString
    srcSpanFile RealSrcSpan
    src = Bool
    False
        | Bool
    otherwise = RealSrcSpan -> RealSrcLoc
    realSrcSpanStart RealSrcSpan
    parent RealSrcLoc -> RealSrcLoc -> Bool
    forall a. Ord a => a -> a -> Bool
    <= RealSrcSpan -> RealSrcLoc
    realSrcSpanStart RealSrcSpan
    src Bool -> Bool -> Bool
    &&
                      RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd RealSrcSpan
    parent   RealSrcLoc -> RealSrcLoc -> Bool
    forall a. Ord a => a -> a -> Bool
    >= RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd RealSrcSpan
    src

    getRealSrcSpan :: RealLocated a -> RealSrcSpan
    getRealSrcSpan :: forall a. RealLocated a -> RealSrcSpan
    getRealSrcSpan (L RealSrcSpan
    l a
    _) = RealSrcSpan
    l

    unRealSrcSpan :: RealLocated a -> a
    unRealSrcSpan :: forall a. RealLocated a -> a
    unRealSrcSpan  (L RealSrcSpan
    _ a
    e) = a
    e

    -- | A location as produced by the parser. Consists of two components:
    --
    -- * The location in the file, adjusted for #line and {-# LINE ... #-} pragmas (RealSrcLoc)
    -- * The location in the string buffer (BufPos) with monotonicity guarantees (see #17632)
    data PsLoc
      = PsLoc { PsLoc -> RealSrcLoc
    psRealLoc :: !RealSrcLoc, PsLoc -> BufPos
    psBufPos :: !BufPos }
      deriving (PsLoc -> PsLoc -> Bool
    (PsLoc -> PsLoc -> Bool) -> (PsLoc -> PsLoc -> Bool) -> Eq PsLoc
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PsLoc -> PsLoc -> Bool
    == :: PsLoc -> PsLoc -> Bool
    $c/= :: PsLoc -> PsLoc -> Bool
    /= :: PsLoc -> PsLoc -> Bool
    Eq, Eq PsLoc
    Eq PsLoc =>
    (PsLoc -> PsLoc -> Ordering)
    -> (PsLoc -> PsLoc -> Bool)
    -> (PsLoc -> PsLoc -> Bool)
    -> (PsLoc -> PsLoc -> Bool)
    -> (PsLoc -> PsLoc -> Bool)
    -> (PsLoc -> PsLoc -> PsLoc)
    -> (PsLoc -> PsLoc -> PsLoc)
    -> Ord PsLoc
    PsLoc -> PsLoc -> Bool
    PsLoc -> PsLoc -> Ordering
    PsLoc -> PsLoc -> PsLoc
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: PsLoc -> PsLoc -> Ordering
    compare :: PsLoc -> PsLoc -> Ordering
    $c< :: PsLoc -> PsLoc -> Bool
    < :: PsLoc -> PsLoc -> Bool
    $c<= :: PsLoc -> PsLoc -> Bool
    <= :: PsLoc -> PsLoc -> Bool
    $c> :: PsLoc -> PsLoc -> Bool
    > :: PsLoc -> PsLoc -> Bool
    $c>= :: PsLoc -> PsLoc -> Bool
    >= :: PsLoc -> PsLoc -> Bool
    $cmax :: PsLoc -> PsLoc -> PsLoc
    max :: PsLoc -> PsLoc -> PsLoc
    $cmin :: PsLoc -> PsLoc -> PsLoc
    min :: PsLoc -> PsLoc -> PsLoc
    Ord, Int -> PsLoc -> ShowS
    [PsLoc] -> ShowS
    PsLoc -> String
    (Int -> PsLoc -> ShowS)
    -> (PsLoc -> String) -> ([PsLoc] -> ShowS) -> Show PsLoc
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PsLoc -> ShowS
    showsPrec :: Int -> PsLoc -> ShowS
    $cshow :: PsLoc -> String
    show :: PsLoc -> String
    $cshowList :: [PsLoc] -> ShowS
    showList :: [PsLoc] -> ShowS
    Show)

    data PsSpan
      = PsSpan { PsSpan -> RealSrcSpan
    psRealSpan :: !RealSrcSpan, PsSpan -> BufSpan
    psBufSpan :: !BufSpan }
      deriving (PsSpan -> PsSpan -> Bool
    (PsSpan -> PsSpan -> Bool)
    -> (PsSpan -> PsSpan -> Bool) -> Eq PsSpan
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: PsSpan -> PsSpan -> Bool
    == :: PsSpan -> PsSpan -> Bool
    $c/= :: PsSpan -> PsSpan -> Bool
    /= :: PsSpan -> PsSpan -> Bool
    Eq, Eq PsSpan
    Eq PsSpan =>
    (PsSpan -> PsSpan -> Ordering)
    -> (PsSpan -> PsSpan -> Bool)
    -> (PsSpan -> PsSpan -> Bool)
    -> (PsSpan -> PsSpan -> Bool)
    -> (PsSpan -> PsSpan -> Bool)
    -> (PsSpan -> PsSpan -> PsSpan)
    -> (PsSpan -> PsSpan -> PsSpan)
    -> Ord PsSpan
    PsSpan -> PsSpan -> Bool
    PsSpan -> PsSpan -> Ordering
    PsSpan -> PsSpan -> PsSpan
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: PsSpan -> PsSpan -> Ordering
    compare :: PsSpan -> PsSpan -> Ordering
    $c< :: PsSpan -> PsSpan -> Bool
    < :: PsSpan -> PsSpan -> Bool
    $c<= :: PsSpan -> PsSpan -> Bool
    <= :: PsSpan -> PsSpan -> Bool
    $c> :: PsSpan -> PsSpan -> Bool
    > :: PsSpan -> PsSpan -> Bool
    $c>= :: PsSpan -> PsSpan -> Bool
    >= :: PsSpan -> PsSpan -> Bool
    $cmax :: PsSpan -> PsSpan -> PsSpan
    max :: PsSpan -> PsSpan -> PsSpan
    $cmin :: PsSpan -> PsSpan -> PsSpan
    min :: PsSpan -> PsSpan -> PsSpan
    Ord, Int -> PsSpan -> ShowS
    [PsSpan] -> ShowS
    PsSpan -> String
    (Int -> PsSpan -> ShowS)
    -> (PsSpan -> String) -> ([PsSpan] -> ShowS) -> Show PsSpan
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> PsSpan -> ShowS
    showsPrec :: Int -> PsSpan -> ShowS
    $cshow :: PsSpan -> String
    show :: PsSpan -> String
    $cshowList :: [PsSpan] -> ShowS
    showList :: [PsSpan] -> ShowS
    Show, Typeable PsSpan
    Typeable PsSpan =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> PsSpan -> c PsSpan)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c PsSpan)
    -> (PsSpan -> Constr)
    -> (PsSpan -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c PsSpan))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PsSpan))
    -> ((forall b. Data b => b -> b) -> PsSpan -> PsSpan)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> PsSpan -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> PsSpan -> r)
    -> (forall u. (forall d. Data d => d -> u) -> PsSpan -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> PsSpan -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan)
    -> Data PsSpan
    PsSpan -> Constr
    PsSpan -> DataType
    (forall b. Data b => b -> b) -> PsSpan -> PsSpan
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> PsSpan -> u
    forall u. (forall d. Data d => d -> u) -> PsSpan -> [u]
    forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PsSpan -> r
    forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PsSpan -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PsSpan
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PsSpan -> c PsSpan
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PsSpan)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PsSpan)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PsSpan -> c PsSpan
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> PsSpan -> c PsSpan
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PsSpan
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PsSpan
    $ctoConstr :: PsSpan -> Constr
    toConstr :: PsSpan -> Constr
    $cdataTypeOf :: PsSpan -> DataType
    dataTypeOf :: PsSpan -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PsSpan)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PsSpan)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PsSpan)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PsSpan)
    $cgmapT :: (forall b. Data b => b -> b) -> PsSpan -> PsSpan
    gmapT :: (forall b. Data b => b -> b) -> PsSpan -> PsSpan
    $cgmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PsSpan -> r
    gmapQl :: forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PsSpan -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PsSpan -> r
    gmapQr :: forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PsSpan -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> PsSpan -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> PsSpan -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PsSpan -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PsSpan -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PsSpan -> m PsSpan
    Data)

    type PsLocated = GenLocated PsSpan

    psLocatedToLocated :: PsLocated a -> Located a
    psLocatedToLocated :: forall a. PsLocated a -> Located a
    psLocatedToLocated (L PsSpan
    sp a
    a) = SrcSpan -> a -> GenLocated SrcSpan a
    forall l e. l -> e -> GenLocated l e
    L (PsSpan -> SrcSpan
    mkSrcSpanPs PsSpan
    sp) a
    a

    advancePsLoc :: PsLoc -> Char -> PsLoc
    advancePsLoc :: PsLoc -> Char -> PsLoc
    advancePsLoc (PsLoc RealSrcLoc
    real_loc BufPos
    buf_loc) Char
    c =
      RealSrcLoc -> BufPos -> PsLoc
    PsLoc (RealSrcLoc -> Char -> RealSrcLoc
    advanceSrcLoc RealSrcLoc
    real_loc Char
    c) (BufPos -> BufPos
    advanceBufPos BufPos
    buf_loc)

    mkPsSpan :: PsLoc -> PsLoc -> PsSpan
    mkPsSpan :: PsLoc -> PsLoc -> PsSpan
    mkPsSpan (PsLoc RealSrcLoc
    r1 BufPos
    b1) (PsLoc RealSrcLoc
    r2 BufPos
    b2) = RealSrcSpan -> BufSpan -> PsSpan
    PsSpan (RealSrcLoc -> RealSrcLoc -> RealSrcSpan
    mkRealSrcSpan RealSrcLoc
    r1 RealSrcLoc
    r2) (BufPos -> BufPos -> BufSpan
    BufSpan BufPos
    b1 BufPos
    b2)

    psSpanStart :: PsSpan -> PsLoc
    psSpanStart :: PsSpan -> PsLoc
    psSpanStart (PsSpan RealSrcSpan
    r BufSpan
    b) = RealSrcLoc -> BufPos -> PsLoc
    PsLoc (RealSrcSpan -> RealSrcLoc
    realSrcSpanStart RealSrcSpan
    r) (BufSpan -> BufPos
    bufSpanStart BufSpan
    b)

    psSpanEnd :: PsSpan -> PsLoc
    psSpanEnd :: PsSpan -> PsLoc
    psSpanEnd (PsSpan RealSrcSpan
    r BufSpan
    b) = RealSrcLoc -> BufPos -> PsLoc
    PsLoc (RealSrcSpan -> RealSrcLoc
    realSrcSpanEnd RealSrcSpan
    r) (BufSpan -> BufPos
    bufSpanEnd BufSpan
    b)

    mkSrcSpanPs :: PsSpan -> SrcSpan
    mkSrcSpanPs :: PsSpan -> SrcSpan
    mkSrcSpanPs (PsSpan RealSrcSpan
    r BufSpan
    b) = RealSrcSpan -> Maybe BufSpan -> SrcSpan
    RealSrcSpan RealSrcSpan
    r (BufSpan -> Maybe BufSpan
    forall a. a -> Maybe a
    Strict.Just BufSpan
    b)

    -- ---------------------------------------------------------------------
    -- The following section contains basic types related to exact printing.
    -- See https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations for
    -- details.
    -- This is only s subset, to prevent import loops. The balance are in
    -- GHC.Parser.Annotation
    -- ---------------------------------------------------------------------

    -- | The anchor for an @'AnnKeywordId'@. The Parser inserts the
    -- @'EpaSpan'@ variant, giving the exact location of the original item
    -- in the parsed source.  This can be replaced by the @'EpaDelta'@
    -- version, to provide a position for the item relative to the end of
    -- the previous item in the source.  This is useful when editing an
    -- AST prior to exact printing the changed one. The list of comments
    -- in the @'EpaDelta'@ variant captures any comments between the prior
    -- output and the thing being marked here, since we cannot otherwise
    -- sort the relative order.

    data EpaLocation' a = EpaSpan !SrcSpan
                        | EpaDelta !DeltaPos !a
                        deriving (Typeable (EpaLocation' a)
    Typeable (EpaLocation' a) =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> EpaLocation' a -> c (EpaLocation' a))
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c (EpaLocation' a))
    -> (EpaLocation' a -> Constr)
    -> (EpaLocation' a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c (EpaLocation' a)))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c (EpaLocation' a)))
    -> ((forall b. Data b => b -> b)
        -> EpaLocation' a -> EpaLocation' a)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r)
    -> (forall u.
        (forall d. Data d => d -> u) -> EpaLocation' a -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> EpaLocation' a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d)
        -> EpaLocation' a -> m (EpaLocation' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> EpaLocation' a -> m (EpaLocation' a))
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d)
        -> EpaLocation' a -> m (EpaLocation' a))
    -> Data (EpaLocation' a)
    EpaLocation' a -> Constr
    EpaLocation' a -> DataType
    (forall b. Data b => b -> b) -> EpaLocation' a -> EpaLocation' a
    forall a. Data a => Typeable (EpaLocation' a)
    forall a. Data a => EpaLocation' a -> Constr
    forall a. Data a => EpaLocation' a -> DataType
    forall a.
    Data a =>
    (forall b. Data b => b -> b) -> EpaLocation' a -> EpaLocation' a
    forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> EpaLocation' a -> u
    forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> EpaLocation' a -> [u]
    forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpaLocation' a)
    forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaLocation' a -> c (EpaLocation' a)
    forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpaLocation' a))
    forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpaLocation' a))
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u.
    Int -> (forall d. Data d => d -> u) -> EpaLocation' a -> u
    forall u. (forall d. Data d => d -> u) -> EpaLocation' a -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpaLocation' a)
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaLocation' a -> c (EpaLocation' a)
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpaLocation' a))
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpaLocation' a))
    $cgfoldl :: forall a (c :: * -> *).
    Data a =>
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaLocation' a -> c (EpaLocation' a)
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> EpaLocation' a -> c (EpaLocation' a)
    $cgunfold :: forall a (c :: * -> *).
    Data a =>
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpaLocation' a)
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (EpaLocation' a)
    $ctoConstr :: forall a. Data a => EpaLocation' a -> Constr
    toConstr :: EpaLocation' a -> Constr
    $cdataTypeOf :: forall a. Data a => EpaLocation' a -> DataType
    dataTypeOf :: EpaLocation' a -> DataType
    $cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpaLocation' a))
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (EpaLocation' a))
    $cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
    (Data a, Typeable t) =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpaLocation' a))
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (EpaLocation' a))
    $cgmapT :: forall a.
    Data a =>
    (forall b. Data b => b -> b) -> EpaLocation' a -> EpaLocation' a
    gmapT :: (forall b. Data b => b -> b) -> EpaLocation' a -> EpaLocation' a
    $cgmapQl :: forall a r r'.
    Data a =>
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    $cgmapQr :: forall a r r'.
    Data a =>
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EpaLocation' a -> r
    $cgmapQ :: forall a u.
    Data a =>
    (forall d. Data d => d -> u) -> EpaLocation' a -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> EpaLocation' a -> [u]
    $cgmapQi :: forall a u.
    Data a =>
    Int -> (forall d. Data d => d -> u) -> EpaLocation' a -> u
    gmapQi :: forall u.
    Int -> (forall d. Data d => d -> u) -> EpaLocation' a -> u
    $cgmapM :: forall a (m :: * -> *).
    (Data a, Monad m) =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    $cgmapMp :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    $cgmapMo :: forall a (m :: * -> *).
    (Data a, MonadPlus m) =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EpaLocation' a -> m (EpaLocation' a)
    Data,EpaLocation' a -> EpaLocation' a -> Bool
    (EpaLocation' a -> EpaLocation' a -> Bool)
    -> (EpaLocation' a -> EpaLocation' a -> Bool)
    -> Eq (EpaLocation' a)
    forall a. Eq a => EpaLocation' a -> EpaLocation' a -> Bool
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: forall a. Eq a => EpaLocation' a -> EpaLocation' a -> Bool
    == :: EpaLocation' a -> EpaLocation' a -> Bool
    $c/= :: forall a. Eq a => EpaLocation' a -> EpaLocation' a -> Bool
    /= :: EpaLocation' a -> EpaLocation' a -> Bool
    Eq,Int -> EpaLocation' a -> ShowS
    [EpaLocation' a] -> ShowS
    EpaLocation' a -> String
    (Int -> EpaLocation' a -> ShowS)
    -> (EpaLocation' a -> String)
    -> ([EpaLocation' a] -> ShowS)
    -> Show (EpaLocation' a)
    forall a. Show a => Int -> EpaLocation' a -> ShowS
    forall a. Show a => [EpaLocation' a] -> ShowS
    forall a. Show a => EpaLocation' a -> String
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: forall a. Show a => Int -> EpaLocation' a -> ShowS
    showsPrec :: Int -> EpaLocation' a -> ShowS
    $cshow :: forall a. Show a => EpaLocation' a -> String
    show :: EpaLocation' a -> String
    $cshowList :: forall a. Show a => [EpaLocation' a] -> ShowS
    showList :: [EpaLocation' a] -> ShowS
    Show)

    type NoCommentsLocation = EpaLocation' NoComments

    data NoComments = NoComments
      deriving (Typeable NoComments
    Typeable NoComments =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> NoComments -> c NoComments)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c NoComments)
    -> (NoComments -> Constr)
    -> (NoComments -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c NoComments))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e))
        -> Maybe (c NoComments))
    -> ((forall b. Data b => b -> b) -> NoComments -> NoComments)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> NoComments -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> NoComments -> r)
    -> (forall u. (forall d. Data d => d -> u) -> NoComments -> [u])
    -> (forall u.
        Int -> (forall d. Data d => d -> u) -> NoComments -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> NoComments -> m NoComments)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NoComments -> m NoComments)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> NoComments -> m NoComments)
    -> Data NoComments
    NoComments -> Constr
    NoComments -> DataType
    (forall b. Data b => b -> b) -> NoComments -> NoComments
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> NoComments -> u
    forall u. (forall d. Data d => d -> u) -> NoComments -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NoComments -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NoComments -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NoComments
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NoComments -> c NoComments
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NoComments)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoComments)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NoComments -> c NoComments
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> NoComments -> c NoComments
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NoComments
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NoComments
    $ctoConstr :: NoComments -> Constr
    toConstr :: NoComments -> Constr
    $cdataTypeOf :: NoComments -> DataType
    dataTypeOf :: NoComments -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NoComments)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NoComments)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoComments)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NoComments)
    $cgmapT :: (forall b. Data b => b -> b) -> NoComments -> NoComments
    gmapT :: (forall b. Data b => b -> b) -> NoComments -> NoComments
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NoComments -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NoComments -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NoComments -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NoComments -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> NoComments -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> NoComments -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NoComments -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NoComments -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NoComments -> m NoComments
    Data,NoComments -> NoComments -> Bool
    (NoComments -> NoComments -> Bool)
    -> (NoComments -> NoComments -> Bool) -> Eq NoComments
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: NoComments -> NoComments -> Bool
    == :: NoComments -> NoComments -> Bool
    $c/= :: NoComments -> NoComments -> Bool
    /= :: NoComments -> NoComments -> Bool
    Eq,Eq NoComments
    Eq NoComments =>
    (NoComments -> NoComments -> Ordering)
    -> (NoComments -> NoComments -> Bool)
    -> (NoComments -> NoComments -> Bool)
    -> (NoComments -> NoComments -> Bool)
    -> (NoComments -> NoComments -> Bool)
    -> (NoComments -> NoComments -> NoComments)
    -> (NoComments -> NoComments -> NoComments)
    -> Ord NoComments
    NoComments -> NoComments -> Bool
    NoComments -> NoComments -> Ordering
    NoComments -> NoComments -> NoComments
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: NoComments -> NoComments -> Ordering
    compare :: NoComments -> NoComments -> Ordering
    $c< :: NoComments -> NoComments -> Bool
    < :: NoComments -> NoComments -> Bool
    $c<= :: NoComments -> NoComments -> Bool
    <= :: NoComments -> NoComments -> Bool
    $c> :: NoComments -> NoComments -> Bool
    > :: NoComments -> NoComments -> Bool
    $c>= :: NoComments -> NoComments -> Bool
    >= :: NoComments -> NoComments -> Bool
    $cmax :: NoComments -> NoComments -> NoComments
    max :: NoComments -> NoComments -> NoComments
    $cmin :: NoComments -> NoComments -> NoComments
    min :: NoComments -> NoComments -> NoComments
    Ord,Int -> NoComments -> ShowS
    [NoComments] -> ShowS
    NoComments -> String
    (Int -> NoComments -> ShowS)
    -> (NoComments -> String)
    -> ([NoComments] -> ShowS)
    -> Show NoComments
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> NoComments -> ShowS
    showsPrec :: Int -> NoComments -> ShowS
    $cshow :: NoComments -> String
    show :: NoComments -> String
    $cshowList :: [NoComments] -> ShowS
    showList :: [NoComments] -> ShowS
    Show)

    -- | Spacing between output items when exact printing.  It captures
    -- the spacing from the current print position on the page to the
    -- position required for the thing about to be printed.  This is
    -- either on the same line in which case is is simply the number of
    -- spaces to emit, or it is some number of lines down, with a given
    -- column offset.  The exact printing algorithm keeps track of the
    -- column offset pertaining to the current anchor position, so the
    -- `deltaColumn` is the additional spaces to add in this case.  See
    -- https://gitlab.haskell.org/ghc/ghc/wikis/api-annotations for
    -- details.
    data DeltaPos
      = SameLine { DeltaPos -> Int
    deltaColumn :: !Int }
      | DifferentLine
          { DeltaPos -> Int
    deltaLine   :: !Int, -- ^ deltaLine should always be > 0
            deltaColumn :: !Int
          } deriving (Int -> DeltaPos -> ShowS
    [DeltaPos] -> ShowS
    DeltaPos -> String
    (Int -> DeltaPos -> ShowS)
    -> (DeltaPos -> String) -> ([DeltaPos] -> ShowS) -> Show DeltaPos
    forall a.
    (Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
    $cshowsPrec :: Int -> DeltaPos -> ShowS
    showsPrec :: Int -> DeltaPos -> ShowS
    $cshow :: DeltaPos -> String
    show :: DeltaPos -> String
    $cshowList :: [DeltaPos] -> ShowS
    showList :: [DeltaPos] -> ShowS
    Show,DeltaPos -> DeltaPos -> Bool
    (DeltaPos -> DeltaPos -> Bool)
    -> (DeltaPos -> DeltaPos -> Bool) -> Eq DeltaPos
    forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
    $c== :: DeltaPos -> DeltaPos -> Bool
    == :: DeltaPos -> DeltaPos -> Bool
    $c/= :: DeltaPos -> DeltaPos -> Bool
    /= :: DeltaPos -> DeltaPos -> Bool
    Eq,Eq DeltaPos
    Eq DeltaPos =>
    (DeltaPos -> DeltaPos -> Ordering)
    -> (DeltaPos -> DeltaPos -> Bool)
    -> (DeltaPos -> DeltaPos -> Bool)
    -> (DeltaPos -> DeltaPos -> Bool)
    -> (DeltaPos -> DeltaPos -> Bool)
    -> (DeltaPos -> DeltaPos -> DeltaPos)
    -> (DeltaPos -> DeltaPos -> DeltaPos)
    -> Ord DeltaPos
    DeltaPos -> DeltaPos -> Bool
    DeltaPos -> DeltaPos -> Ordering
    DeltaPos -> DeltaPos -> DeltaPos
    forall a.
    Eq a =>
    (a -> a -> Ordering)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> Bool)
    -> (a -> a -> a)
    -> (a -> a -> a)
    -> Ord a
    $ccompare :: DeltaPos -> DeltaPos -> Ordering
    compare :: DeltaPos -> DeltaPos -> Ordering
    $c< :: DeltaPos -> DeltaPos -> Bool
    < :: DeltaPos -> DeltaPos -> Bool
    $c<= :: DeltaPos -> DeltaPos -> Bool
    <= :: DeltaPos -> DeltaPos -> Bool
    $c> :: DeltaPos -> DeltaPos -> Bool
    > :: DeltaPos -> DeltaPos -> Bool
    $c>= :: DeltaPos -> DeltaPos -> Bool
    >= :: DeltaPos -> DeltaPos -> Bool
    $cmax :: DeltaPos -> DeltaPos -> DeltaPos
    max :: DeltaPos -> DeltaPos -> DeltaPos
    $cmin :: DeltaPos -> DeltaPos -> DeltaPos
    min :: DeltaPos -> DeltaPos -> DeltaPos
    Ord,Typeable DeltaPos
    Typeable DeltaPos =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> DeltaPos -> c DeltaPos)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c DeltaPos)
    -> (DeltaPos -> Constr)
    -> (DeltaPos -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c DeltaPos))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeltaPos))
    -> ((forall b. Data b => b -> b) -> DeltaPos -> DeltaPos)
    -> (forall r r'.
        (r -> r' -> r)
        -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r)
    -> (forall r r'.
        (r' -> r -> r)
        -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r)
    -> (forall u. (forall d. Data d => d -> u) -> DeltaPos -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> DeltaPos -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos)
    -> Data DeltaPos
    DeltaPos -> Constr
    DeltaPos -> DataType
    (forall b. Data b => b -> b) -> DeltaPos -> DeltaPos
    forall a.
    Typeable a =>
    (forall (c :: * -> *).
     (forall d b. Data d => c (d -> b) -> d -> c b)
     -> (forall g. g -> c g) -> a -> c a)
    -> (forall (c :: * -> *).
        (forall b r. Data b => c (b -> r) -> c r)
        -> (forall r. r -> c r) -> Constr -> c a)
    -> (a -> Constr)
    -> (a -> DataType)
    -> (forall (t :: * -> *) (c :: * -> *).
        Typeable t =>
        (forall d. Data d => c (t d)) -> Maybe (c a))
    -> (forall (t :: * -> * -> *) (c :: * -> *).
        Typeable t =>
        (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
    -> ((forall b. Data b => b -> b) -> a -> a)
    -> (forall r r'.
        (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall r r'.
        (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
    -> (forall u. (forall d. Data d => d -> u) -> a -> [u])
    -> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
    -> (forall (m :: * -> *).
        Monad m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> (forall (m :: * -> *).
        MonadPlus m =>
        (forall d. Data d => d -> m d) -> a -> m a)
    -> Data a
    forall u. Int -> (forall d. Data d => d -> u) -> DeltaPos -> u
    forall u. (forall d. Data d => d -> u) -> DeltaPos -> [u]
    forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r
    forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r
    forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeltaPos
    forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeltaPos -> c DeltaPos
    forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeltaPos)
    forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeltaPos)
    $cgfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeltaPos -> c DeltaPos
    gfoldl :: forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> DeltaPos -> c DeltaPos
    $cgunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeltaPos
    gunfold :: forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DeltaPos
    $ctoConstr :: DeltaPos -> Constr
    toConstr :: DeltaPos -> Constr
    $cdataTypeOf :: DeltaPos -> DataType
    dataTypeOf :: DeltaPos -> DataType
    $cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeltaPos)
    dataCast1 :: forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DeltaPos)
    $cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeltaPos)
    dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DeltaPos)
    $cgmapT :: (forall b. Data b => b -> b) -> DeltaPos -> DeltaPos
    gmapT :: (forall b. Data b => b -> b) -> DeltaPos -> DeltaPos
    $cgmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r
    gmapQl :: forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r
    $cgmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r
    gmapQr :: forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DeltaPos -> r
    $cgmapQ :: forall u. (forall d. Data d => d -> u) -> DeltaPos -> [u]
    gmapQ :: forall u. (forall d. Data d => d -> u) -> DeltaPos -> [u]
    $cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeltaPos -> u
    gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DeltaPos -> u
    $cgmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    gmapM :: forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    $cgmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    gmapMp :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    $cgmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    gmapMo :: forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DeltaPos -> m DeltaPos
    Data)

    -- | Smart constructor for a 'DeltaPos'. It preserves the invariant
    -- that for the 'DifferentLine' constructor 'deltaLine' is always > 0.
    deltaPos :: Int -> Int -> DeltaPos
    deltaPos :: Int -> Int -> DeltaPos
    deltaPos Int
    l Int
    c = case Int
    l of
      Int
    0 -> Int -> DeltaPos
    SameLine Int
    c
      Int
    _ -> Int -> Int -> DeltaPos
    DifferentLine Int
    l Int
    c

    getDeltaLine :: DeltaPos -> Int
    getDeltaLine :: DeltaPos -> Int
    getDeltaLine (SameLine Int
    _) = Int
    0
    getDeltaLine (DifferentLine Int
    r Int
    _) = Int
    r

    instance Outputable NoComments where
      ppr :: NoComments -> SDoc
    ppr NoComments
    NoComments = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "NoComments"

    instance (Outputable a) => Outputable (EpaLocation' a) where
      ppr :: EpaLocation' a -> SDoc
    ppr (EpaSpan SrcSpan
    r) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "EpaSpan" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> SrcSpan -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr SrcSpan
    r
      ppr (EpaDelta DeltaPos
    d a
    cs) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "EpaDelta" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> DeltaPos -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr DeltaPos
    d SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> a -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr a
    cs

    instance Outputable DeltaPos where
      ppr :: DeltaPos -> SDoc
    ppr (SameLine Int
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "SameLine" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    c
      ppr (DifferentLine Int
    l Int
    c) = String -> SDoc
    forall doc. IsLine doc => String -> doc
    text String
    "DifferentLine" SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    l SDoc -> SDoc -> SDoc
    forall doc. IsLine doc => doc -> doc -> doc
    <+> Int -> SDoc
    forall a. Outputable a => a -> SDoc
    ppr Int
    c