SrcLoc(..), RealSrcLoc,

         mkSrcLoc, noSrcLoc,

         srcLocFile, srcLocLine, srcLocCol,

         mkSrcSpan, srcLocSpan, isGoodSrcSpan, noSrcSpan,

         srcSpanStart, srcSpanEnd,

         srcSpanFile,

 addSourceToTokens loc buf (t@(L span _) : ts)

     = case span of

       UnhelpfulSpan _ -> (t,"") : addSourceToTokens loc buf ts

       RealSrcSpan s _ -> (t,str) : addSourceToTokens newLoc newBuf ts

         where

           (newLoc, newBuf, str) = go "" loc buf

     where sourceFile = getFile $ map (getLoc . fst) ts

           getFile [] = panic "showRichTokenStream: No source file found"

           getFile (UnhelpfulSpan _ : xs) = getFile xs

           getFile (RealSrcSpan s _ : _) = srcSpanFile s

           startLoc = mkRealSrcLoc sourceFile 1 1

           go _ [] = id

           go loc ((L span _, str):ts)

               = case span of

                 UnhelpfulSpan _ -> go loc ts

                 RealSrcSpan s _

                  | locLine == tokLine -> ((replicate (tokCol - locCol) ' ') ++)

                                        . (str ++)

 docStringChunks :: HsDocString -> [LHsDocStringChunk]

 docStringChunks (MultiLineDocString _ (x:|xs)) = x:xs

 docStringChunks (NestedDocString _ x) = [x]

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

 pprHsDocString :: HsDocString -> SDoc

                   ; return (RealSrcSpan (dsl_loc env) Strict.Nothing) }

 putSrcSpanDs :: SrcSpan -> DsM a -> DsM a

 putSrcSpanDs (RealSrcSpan real_span _) thing_inside

   = updLclEnv (\ env -> env {dsl_loc = real_span}) thing_inside

 putSrcSpanDsA :: EpAnn ann -> DsM a -> DsM a

 putSrcSpanDsA loc = putSrcSpanDs (locA loc)

                       , blackList    = Set.fromList $

                                        mapMaybe (\tyCon -> case getSrcSpan (tyConName tyCon) of

                                                              RealSrcSpan l _ -> Just l

                                                 tyCons

                       , density      = mkDensity tickish $ ticks_profAuto cfg

                       , this_mod     = mod

 isGoodSrcSpan' :: SrcSpan -> Bool

 isGoodSrcSpan' pos@(RealSrcSpan _ _) = srcSpanStart pos /= srcSpanEnd pos

 isGoodTickSrcSpan :: SrcSpan -> TM Bool

 isGoodTickSrcSpan pos = do

 withBlackListed :: SrcSpan -> TM a -> TM a

 withBlackListed (RealSrcSpan ss _) = withEnv (\ env -> env { blackList = Set.insert ss (blackList env) })

 isBlackListed :: SrcSpan -> TM Bool

 isBlackListed (RealSrcSpan pos _) = TM $ \ env st -> (Set.member pos (blackList env), noFVs, st)

 -- the tick application inherits the source position of its

 -- expression argument to support nested box allocations

             let node = Node (mkSourcedNodeInfo org ni) spn []

                 ni = NodeInfo mempty [] $ M.fromList [mkNodeInfo e]

               in (xs,node:ys)

         _ -> (mkNodeInfo e : xs,ys)

       (nis,asts) = foldr go ([],[]) elts

 getRealSpan :: SrcSpan -> Maybe Span

 getRealSpan (RealSrcSpan sp _) = Just sp

 getRealSpan _ = Nothing

 grhss_span :: (Anno (GRHS (GhcPass p) (LocatedA (body (GhcPass p)))) ~ EpAnn NoEpAnns)

 instance ToHie (Context (Located a)) => ToHie (Context (LocatedA a)) where

   toHie (C c (L l a)) = toHie (C c (L (locA l) a))

                       Nothing -> varType name'

                       Just dc -> dataConWrapperType dc

           -- insert the entity info for the name into the entity_infos map

                             (IdentifierDetails (Just ty)

                                                (S.singleton context)))

       C (EvidenceVarBind i _ sp)  (L _ name) -> do

         addUnlocatedEvBind name (EvidenceVarBind i ModuleScope sp)

         pure []

       _ -> pure []

 instance ToHie (Context (Located Name)) where

   toHie c = case c of

       C context (L (RealSrcSpan span _) name')

       scopes <- maybeToList $ foldMap getScopeFromContext (identInfo dets)

       let binding = foldMap (First . getBindSiteFromContext) (identInfo dets)

       return $ Just (scopes, getFirst binding)

   _ -> Nothing

 getScopeFromContext :: ContextInfo -> Maybe [Scope]

 definedInAsts :: M.Map HiePath (HieAST a) -> Name -> Bool

 definedInAsts asts n = case nameSrcSpan n of

   RealSrcSpan sp _ -> M.member (HiePath (srcSpanFile sp)) asts

   _ -> False

 getEvidenceBindDeps :: ContextInfo -> [Name]

   org <- ask

   let e = mkSourcedNodeInfo org $ emptyNodeInfo

   pure [Node e span []]

 locOnly _ = pure []

 locOnlyE :: Monad m => EpaLocation -> ReaderT NodeOrigin m [HieAST a]

 mkScope :: (HasLoc a) => a -> Scope

 mkScope a = case getHasLoc a of

               (RealSrcSpan sp _) -> LocalScope sp

               _ -> NoScope

 combineScopes :: Scope -> Scope -> Scope

   org <- ask

   pure $ case spn of

     RealSrcSpan span _ -> [Node (mkSourcedNodeInfo org $ simpleNodeInfo cons typ) span []]

     _ -> []

   where

     cons = mkFastString . show . toConstr $ x

   pure $ case spn of

     RealSrcSpan span _ ->

       [Node (mkSourcedNodeInfo org $ NodeInfo (S.singleton (NodeAnnotation cons typ)) [etyp] M.empty) span []]

     _ -> []

   where

     cons = mkFastString . show . toConstr $ x

     plausibleIdents = case l of

       RealSrcSpan span _ -> [(RealSrcSpan span' Strict.Nothing, tok) | (span', tok) <- alexScanTokens (realSrcSpanStart span) bs]

       UnhelpfulSpan reason -> [(UnhelpfulSpan reason, tok) | (_, tok) <- alexScanTokens fakeLoc bs]

     fakeLoc = mkRealSrcLoc nilFS 0 0

       = [(RealSrcSpan span' Strict.Nothing, tok) | (span', tok) <- alexScanTokens (realSrcSpanStart span) s]

     plausibleIdents (L (UnhelpfulSpan reason) (HsDocStringChunk s))

       = [(UnhelpfulSpan reason, tok) | (_, tok) <- alexScanTokens fakeLoc s] -- preserve the original reason

     fakeLoc = mkRealSrcLoc nilFS 0 0

       buffer = stringBufferFromByteString str0

       realSrcLc = case mloc of

         RealSrcSpan loc _ -> realSrcSpanStart loc

         UnhelpfulSpan _ -> mkRealSrcLoc nilFS 0 0

       pstate = initParserState pflags buffer realSrcLc

   in case unP identParser pstate of

     POk _ name -> Just $ case mloc of

        RealSrcSpan _ _ -> reLoc name

     _ -> Nothing

 }

           then return  (ExplicitList noExtField exps', fvs)

           else

     do { (from_list_n_name, fvs') <- lookupSyntaxName fromListNName

        ; let rn_list  = ExplicitList noExtField exps'

              lit_n    = mkIntegralLit (length exps)

              hs_lit   = genHsIntegralLit lit_n

        ; return ( mkExpandedExpr rn_list exp_list

                 , fvs `plusFV` fvs') } }

 insertImportMap gre@(GRE { gre_imp = imp_specs }) importMap

   | RealSrcSpan importSpan _ <- is_dloc best_imp_spec =

       importMap{im_imports = insertElem importSpan gre $ im_imports importMap}

       importMap{im_generatedImports = insertElem (moduleName $ is_mod best_imp_spec) gre $ im_generatedImports importMap}

   | otherwise = importMap

   where

     -- should match logic in insertImportMap

     case locA srcSpan of

       RealSrcSpan realSrcSpan _ -> realSrcSpan `Map.lookup` im_imports importMap

       _ -> Nothing

 warnUnusedImport :: GlobalRdrEnv -> ImportDeclUsage -> RnM ()

 checkConName :: RdrName -> TcRn ()

 checkConName name

   = checkErr (isRdrDataCon name || isRdrTc name) (TcRnIllegalDataCon name)

         DeprecationWarnings(..), warnIfDeprecated,

         checkUnusedRecordWildcard,

         badQualBndrErr, typeAppErr, badFieldConErr,

         genLHsApp, genAppType,

         genLHsLit, genHsIntegralLit, genHsTyLit, genSimpleConPat,

         genVarPat, genWildPat,

 -- See Note [Rebindable syntax and XXExprGhcRn]

 wrapGenSpan x = L (noAnnSrcSpan generatedSrcSpan) x

 wrapNoSpan :: (HasAnnotation an) => a -> GenLocated an a

 -- Wrap something in a "noSrcSpan"

 -- See Note [Rebindable syntax and XXExprGhcRn]

 -- | GHC API debugger module for finding and setting breakpoints.

 --

 -- This module is user facing and is at least used by `GHCi` and `ghc-debugger`

 -- | Returns the span of the largest tick containing the srcspan given

 enclosingTickSpan :: TickArray -> SrcSpan -> RealSrcSpan

 enclosingTickSpan _ (UnhelpfulSpan _) = panic "enclosingTickSpan UnhelpfulSpan"

 enclosingTickSpan ticks (RealSrcSpan src _) =

   assert (inRange (bounds ticks) line) $

     List.minimumBy leftmostLargestRealSrcSpan $ enclosing_spans

           return $ Just $ getBreakSourceMod ibi brks

       ix ->

           Just <$> getHistoryModule hug (resumeHistory r !! (ix-1))

   do expand_stmts_expr <- expand_do_stmts doFlavour lstmts

      let expansion = genHsExpApps then_op  -- (>>)

                      [ L e_lspan (mkExpandedStmt stmt doFlavour e)

                      , expand_stmts_expr ]

      return $ L loc (mkExpandedStmt stmt doFlavour expansion)

                            -- error context to push when typechecking

                            -- the expanded code

                         )

   = do {  -- STEP 0: typecheck the record_expr, the record to be updated.

           --

           -- Until GHC proposal #366 is implemented, we still use the type of

              ds_expr = HsLet noExtField let_binds (wrapGenSpan case_expr)

              case_expr :: HsExpr GhcRn

                        $ mkMatchGroup (Generated OtherExpansion DoPmc) (wrapGenSpan matches)

              matches :: [LMatch GhcRn (LHsExpr GhcRn)]

              matches = map make_pat (NE.toList relevant_cons)

   qLocation = do { m <- getModule

                  ; l <- getSrcSpanM

                  ; r <- case l of

                         UnhelpfulSpan _ -> pprPanic "qLocation: Unhelpful location"

                                                     (ppr l)

                  ; return (TH.Loc { TH.loc_filename = unpackFS (srcSpanFile r)

                                   , TH.loc_module   = moduleNameString (moduleName m)

                                   , TH.loc_package  = unitString (moduleUnit m)

 -- for the ctl_in_gen_code manipulation

 setCtLocEnvLoc env (RealSrcSpan loc _)

   = env { ctl_loc = loc, ctl_in_gen_code = False }

   | isGeneratedSrcSpan loc

   = env { ctl_in_gen_code = True }

   | otherwise

   -- * Error management

   getSrcCodeOrigin,

   inGeneratedCode,

   wrapLocM, wrapLocFstM, wrapLocFstMA, wrapLocSndM, wrapLocSndMA, wrapLocM_,

   wrapLocMA_,wrapLocMA,

         -- Avoid clash with Name.getSrcLoc

 getSrcSpanM = do { env <- getLclEnv; return (RealSrcSpan (getLclEnvLoc env) Strict.Nothing) }

 -- See Note [Error contexts in generated code]

 inGeneratedCode :: TcRn Bool

 inGeneratedCode = lclEnvInGeneratedCode <$> getLclEnv

   SevIgnore -> const mempty

 getCaretDiagnostic :: MessageClass -> SrcSpan -> IO SDoc

 getCaretDiagnostic msg_class (RealSrcSpan span _) =

   caretDiagnostic <$> getSrcLine (srcSpanFile span) row

   where

         caretEllipsis | multiline = "..."

                       | otherwise = ""

         caretLine = replicate start ' ' ++ replicate width '^' ++ caretEllipsis

 --

 -- Queries

 --

 import GHC.Types.Id

 import GHC.Types.Name

 import GHC.Types.Name.Reader (RdrName,ImpDeclSpec (..), rdrNameOcc, rdrNameSpace)

 import GHC.Unit.Module.Imported (ImportedModsVal(..))

 import GHC.Unit.Types

 import GHC.Utils.Outputable

         LocallyBoundAt loc ->

           case loc of

             UnhelpfulSpan l -> parens (ppr l)

             RealSrcSpan l _ -> parens (text "line" <+> int (srcSpanStartLine l))

         ImportedBy is ->

           parens (text "imported from" <+> ppr (moduleName $ is_mod is))

      -- False < True, so if e1 is explicit and e2 is not, we get GT

     compareGenerated UnhelpfulSpan{} UnhelpfulSpan{} = EQ

     compareGenerated RealSrcSpan{} RealSrcSpan{} = EQ

 {- Note [Choosing the best import declaration]

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

 pprLoc :: SrcSpan -> SDoc

 pprLoc (RealSrcSpan s _)  = text "at" <+> ppr s

 pprLoc (UnhelpfulSpan {}) = empty

 -- | Indicate if the given name is the "@" operator

 opIsAt :: RdrName -> Bool

         -- * SrcSpan

         RealSrcSpan,            -- Abstract

         SrcSpan(..),

         UnhelpfulSpanReason(..),

         -- ** Constructing SrcSpan

         pprUserSpan,

         unhelpfulSpanFS,

         srcSpanToRealSrcSpan,

         -- ** Unsafely deconstructing SrcSpan

         -- These are dubious exports, because they crash on some inputs

 lookupSrcSpan :: SrcSpan -> Map.Map RealSrcSpan a -> Maybe a

 lookupSrcSpan (RealSrcSpan l _) = Map.lookup l

 instance Outputable RealSrcLoc where

     ppr (SrcLoc (LexicalFastString src_path) src_line src_col)

 -- or a human-readable description of a location.

 data SrcSpan =

     RealSrcSpan !RealSrcSpan !(Strict.Maybe BufSpan)  -- See Note [Why Maybe BufPos]

   | UnhelpfulSpan !UnhelpfulSpanReason

   deriving (Eq, Show) -- Show is used by GHC.Parser.Lexer, because we

                       -- derive Show for Token

 data UnhelpfulSpanReason

   = UnhelpfulNoLocationInfo

   | UnhelpfulWiredIn

   | UnhelpfulInteractive

   | UnhelpfulOther !FastString

   deriving (Eq, Show)

 instance ToJson SrcSpan where

   json (UnhelpfulSpan {} ) = JSNull --JSObject [( "type", "unhelpful")]

   json (RealSrcSpan rss _) = json rss

 instance ToJson RealSrcSpan where

   json (RealSrcSpan'{..}) = JSObject [ ("file", JSString (unpackFS srcSpanFile)),

                                        ("start", start),

 instance NFData SrcSpan where

   rnf (RealSrcSpan a1 a2) = rnf a1 `seq` rnf a2

   rnf (UnhelpfulSpan a1) = rnf a1

 instance NFData UnhelpfulSpanReason where

   rnf (UnhelpfulNoLocationInfo) = ()

   rnf (UnhelpfulWiredIn) = ()

   rnf (UnhelpfulInteractive) = ()

   rnf (UnhelpfulOther a1) = rnf a1

 getBufSpan :: SrcSpan -> Strict.Maybe BufSpan

 getBufSpan (RealSrcSpan _ mbspan) = mbspan

 -- | Built-in "bad" 'SrcSpan's for common sources of location uncertainty

 noSrcSpan, generatedSrcSpan, wiredInSrcSpan, interactiveSrcSpan :: SrcSpan

 noSrcSpan          = UnhelpfulSpan UnhelpfulNoLocationInfo

 wiredInSrcSpan     = UnhelpfulSpan UnhelpfulWiredIn

 interactiveSrcSpan = UnhelpfulSpan UnhelpfulInteractive

 isGeneratedSrcSpan :: SrcSpan -> Bool

 isGeneratedSrcSpan _                                  = False

 isNoSrcSpan :: SrcSpan -> Bool

 combineSrcSpans :: SrcSpan -> SrcSpan -> SrcSpan

 combineSrcSpans (UnhelpfulSpan _) r = r -- this seems more useful

 combineSrcSpans l (UnhelpfulSpan _) = l

 combineSrcSpans (RealSrcSpan span1 mbspan1) (RealSrcSpan span2 mbspan2)

   | srcSpanFile span1 == srcSpanFile span2

       = RealSrcSpan (combineRealSrcSpans span1 span2) (liftA2 combineBufSpans mbspan1 mbspan2)

 -- | Convert a SrcSpan into one that represents only its first character

 srcSpanFirstCharacter :: SrcSpan -> SrcSpan

 srcSpanFirstCharacter l@(UnhelpfulSpan {}) = l

 srcSpanFirstCharacter (RealSrcSpan span mbspan) =

     RealSrcSpan (mkRealSrcSpan loc1 loc2) (fmap mkBufSpan mbspan)

   where

 -- | Test if a 'SrcSpan' is "good", i.e. has precise location information

 isGoodSrcSpan :: SrcSpan -> Bool

 isGoodSrcSpan (RealSrcSpan _ _) = True

 isOneLineSpan :: SrcSpan -> Bool

 -- ^ True if the span is known to straddle only one line.

 -- For "bad" 'SrcSpan', it returns False

 isOneLineSpan (RealSrcSpan s _) = srcSpanStartLine s == srcSpanEndLine s

 isZeroWidthSpan :: SrcSpan -> Bool

 -- ^ True if the span has a width of zero, as returned for "virtual"

 -- For "bad" 'SrcSpan', it returns False

 isZeroWidthSpan (RealSrcSpan s _) = srcSpanStartLine s == srcSpanEndLine s

                                  && srcSpanStartCol s == srcSpanEndCol s

 -- | Tests whether the first span "contains" the other span, meaning

 -- that it covers at least as much source code. True where spans are equal.

 -- | Returns the location at the start of the 'SrcSpan' or a "bad" 'SrcSpan' if that is unavailable

 srcSpanStart :: SrcSpan -> SrcLoc

 srcSpanStart (UnhelpfulSpan r) = UnhelpfulLoc (unhelpfulSpanFS r)

 srcSpanStart (RealSrcSpan s b) = RealSrcLoc (realSrcSpanStart s) (fmap bufSpanStart b)

 -- | Returns the location at the end of the 'SrcSpan' or a "bad" 'SrcSpan' if that is unavailable

 srcSpanEnd :: SrcSpan -> SrcLoc

 srcSpanEnd (UnhelpfulSpan r) = UnhelpfulLoc (unhelpfulSpanFS r)

 srcSpanEnd (RealSrcSpan s b) = RealSrcLoc (realSrcSpanEnd s) (fmap bufSpanEnd b)

 realSrcSpanStart :: RealSrcSpan -> RealSrcLoc

 -- | Obtains the filename for a 'SrcSpan' if it is "good"

 srcSpanFileName_maybe :: SrcSpan -> Maybe FastString

 srcSpanFileName_maybe (RealSrcSpan s _) = Just (srcSpanFile s)

 srcSpanToRealSrcSpan :: SrcSpan -> Maybe RealSrcSpan

 srcSpanToRealSrcSpan (RealSrcSpan ss _) = Just ss

   UnhelpfulNoLocationInfo -> fsLit "<no location info>"

   UnhelpfulWiredIn        -> fsLit "<wired into compiler>"

   UnhelpfulInteractive    -> fsLit "<interactive>"

 pprUnhelpfulSpanReason :: UnhelpfulSpanReason -> SDoc

 pprUnhelpfulSpanReason r = ftext (unhelpfulSpanFS r)

 pprUserSpan :: Bool -> SrcSpan -> SDoc

 pprUserSpan _         (UnhelpfulSpan r) = pprUnhelpfulSpanReason r

 pprUserSpan show_path (RealSrcSpan s _) = pprUserRealSpan show_path s

 pprUserRealSpan :: Bool -> RealSrcSpan -> SDoc

 compareSrcSpanBy :: (RealSrcSpan -> RealSrcSpan -> Ordering) -> SrcSpan -> SrcSpan -> Ordering

 compareSrcSpanBy cmp (RealSrcSpan a _) (RealSrcSpan b _) = cmp a b

 compareSrcSpanBy _   (UnhelpfulSpan _) (RealSrcSpan _ _) = GT

 -- | Determines whether a span encloses a given line and column index

 spans :: SrcSpan -> (Int, Int) -> Bool

 spans (RealSrcSpan span _) (l,c) = realSrcSpanStart span <= loc && loc <= realSrcSpanEnd span

    where loc = mkRealSrcLoc (srcSpanFile span) l c

 -- | Determines whether a span is enclosed by another one

 isSubspanOf :: SrcSpan -- ^ The span that may be enclosed by the other

     UnhelpfulNoLocationInfo -> putByte bh 0

     UnhelpfulWiredIn        -> putByte bh 1

     UnhelpfulInteractive    -> putByte bh 2

   get bh = do

     h <- getByte bh

       0 -> return UnhelpfulNoLocationInfo

       1 -> return UnhelpfulWiredIn

       2 -> return UnhelpfulInteractive

       _ -> UnhelpfulOther <$> get bh

 newtype BinSrcSpan = BinSrcSpan { unBinSrcSpan :: SrcSpan }