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 ++)

                   ; 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') } }

         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))

   | otherwise

   = pprPanic "expand_do_stmts: The impossible happened, missing bind operator from renamer" (text "stmt" <+> ppr  stmt)

 -- See Note [BodyStmt] in Language.Haskell.Syntax.Expr

 -- See  Note [Expanding HsDo with XXExprGhcRn] Equation (1) below

 --              stmts ~~> stmts'

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

 --      e ; stmts ~~> (>>) e stmts'

 expand_do_stmts doFlavour

        ((L loc (RecStmt { recS_stmts = L stmts_loc rec_stmts

   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

 setSrcSpan (RealSrcSpan loc _) thing_inside

   = updLclCtxt (\env -> env { tcl_loc = loc }) thing_inside

   = thing_inside

 getSrcCodeOrigin :: TcRn (Maybe SrcCodeOrigin)

   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

 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

 instance ToJson SrcSpan where

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

   json (RealSrcSpan rss _) = json rss

 instance ToJson RealSrcSpan where

 instance NFData SrcSpan where

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

   rnf (UnhelpfulSpan a1) = rnf a1

 instance NFData UnhelpfulSpanReason where

   rnf (UnhelpfulNoLocationInfo) = ()

 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

 isGeneratedSrcSpan :: SrcSpan -> Bool

 isGeneratedSrcSpan (UnhelpfulSpan UnhelpfulGenerated) = True

 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

 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

           putByte bh 1

           put_ bh s

   get bh = do

           h <- getByte bh

           case h of

             0 -> do BinSpan ss <- get bh

                     return $ BinSrcSpan (RealSrcSpan ss Strict.Nothing)

                     return $ BinSrcSpan (UnhelpfulSpan s)

 {-

                                                 , ("endCol", json $ srcSpanEndCol rss)

                                                 ]

                    where file = unpackFS $ srcSpanFile rss

 -- | The default 'LogAction' prints to 'stdout' and 'stderr'.

 --

 class ContainsLogger t where

     extractLogger :: t -> Logger

 -- @<filename>:(<line>,<col>)-(<line-end>,<col-end>)@

 -- while simply unpacking 'UnhelpfulSpan's

 showSrcSpan :: SrcSpan -> String

 -- | Variant of 'showSrcSpan' for 'RealSrcSpan's

 showRealSrcSpan :: RealSrcSpan -> String

       mb_span <- getCurrentBreakSpan

       case mb_span of

         Nothing  -> stepCmd []

            md <- fromMaybe (panic "stepLocalCmd") <$> getCurrentBreakModule

            current_toplevel_decl <- flip enclosingTickSpan loc <$> getTickArray md

            doContinue (GHC.LocalStep (RealSrcSpan current_toplevel_decl Strict.Nothing))

 stepModuleCmd :: GhciMonad m => String -> m ()

 stepModuleCmd arg = withSandboxOnly ":stepmodule" $ step arg

           printForUser $ text "Not stopped at a breakpoint; nothing to list"

       Just (RealSrcSpan pan _) ->

           listAround pan True

           do resumes <- GHC.getResumeContext

              case resumes of

                  [] -> panic "No resumes"

       Just name ->

         case getSrcSpan name of

           UnhelpfulSpan {} -> tryExternalModuleResolution

           RealSrcSpan   {} -> return (getName name)

   where

     rdrs = modInfo_rdrs mi

             dp = adjustDeltaForOffset

                    off (ss2delta priorEndAfterComments r)

         Just (EpaSpan (UnhelpfulSpan r)) -> panic $ "enterAnn: UnhelpfulSpan:" ++ show r

   when (isJust med) $ debugM $ "enterAnn:(med,edp)=" ++ showAst (med,edp)

   when (isJust medr) $ setExtraDPReturn medr

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

 printStringAtAAC :: (Monad m, Monoid w)

   => CaptureComments -> EpaLocation -> String -> EP w m EpaLocation

 printStringAtAAC capture (EpaSpan (RealSrcSpan r _)) s = printStringAtRsC capture r s

 printStringAtAAC capture (EpaDelta ss d cs) s = do

   mapM_ printOneComment $ concatMap tokComment cs

   pe1 <- getPriorEndD

         let dp = ss2delta pe r

         debugM $ "printOneComment:(dp,pe,loc)=" ++ showGhc (dp,pe,loc)

         adjustDeltaForOffsetM dp

   mep <- getExtraDP

   dp' <- case mep of

     Just (EpaDelta _ edp _) -> do

   where

     moveComments :: GHC.EpaLocation -> GHC.LHsDecl GHC.GhcPs -> GHC.EpAnnComments