SrcLoc(..), RealSrcLoc,

         mkSrcLoc, noSrcLoc,

         srcLocFile, srcLocLine, srcLocCol,

         mkSrcSpan, srcLocSpan, isGoodSrcSpan, noSrcSpan,

         srcSpanStart, srcSpanEnd,

         srcSpanFile,

 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

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

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

               in (xs,node:ys)

           | srcSpanFile spn == file ->

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

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

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

   toHie c = case c of

       C context (L (RealSrcSpan span _) name') -> toHieCtxLocVar context span name'

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

         addUnlocatedEvBind name (EvidenceVarBind i ModuleScope sp)

         pure []

       scopes <- maybeToList $ foldMap getScopeFromContext (identInfo dets)

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

       return $ Just (scopes, getFirst binding)

     ast <- M.lookup (HiePath (srcSpanFile sp)) asts

     defNode <- selectLargestContainedBy sp ast

     getFirst $ foldMap First $ do -- @[]

 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 []]

   org <- ask

   let e = mkSourcedNodeInfo org $ emptyNodeInfo

   pure [Node e span []]

 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 []]

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

     _ -> []

   where

           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

 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)

 -- See Note [Rebindable syntax and XXExprGhcRn]

 wrapGenSpan x = L (noAnnSrcSpan generatedSrcSpan) x

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

 -- Wrap something in a "noSrcSpan"

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

                  ; r <- case l of

                         RealSrcSpan s _ -> return s

                         GeneratedSrcSpan l -> pprPanic "qLocation: generatedSrcSpan"

                         UnhelpfulSpan _ -> pprPanic "qLocation: Unhelpful location"

                                                     (ppr l)

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

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

         -- * SrcSpan

         RealSrcSpan,            -- Abstract

         SrcSpan(..),

         UnhelpfulSpanReason(..),

         -- ** Constructing SrcSpan

         pprUserSpan,

         unhelpfulSpanFS,

         srcSpanToRealSrcSpan,

         -- ** Unsafely deconstructing SrcSpan

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

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

 noSrcSpan          = UnhelpfulSpan UnhelpfulNoLocationInfo

 wiredInSrcSpan     = UnhelpfulSpan UnhelpfulWiredIn

 interactiveSrcSpan = UnhelpfulSpan UnhelpfulInteractive

 isGeneratedSrcSpan :: SrcSpan -> Bool

 isGeneratedSrcSpan (GeneratedSrcSpan{})               = True

 isGeneratedSrcSpan _                                  = False

 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)

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

   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

     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 }

 -- See Note [Source Location Wrappers]

 instance Binary BinSrcSpan where

   put_ bh (BinSrcSpan (RealSrcSpan ss _sb)) = do

   put_ bh (BinSrcSpan (GeneratedSrcSpan ss)) = do

           putByte bh 2

   get bh = do

           h <- getByte bh

                     return $ BinSrcSpan (RealSrcSpan ss Strict.Nothing)

             1 -> do s <- get bh

                     return $ BinSrcSpan (UnhelpfulSpan s)

                     return $ BinSrcSpan (GeneratedSrcSpan ss)

 -- while simply unpacking 'UnhelpfulSpan's

 showSrcSpan :: SrcSpan -> String

 showSrcSpan (UnhelpfulSpan s)    = unpackFS (unhelpfulSpanFS s)

 showSrcSpan (RealSrcSpan spn _)  = showRealSrcSpan spn

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

     parsePlainTok inPrag = do

       (bInit, lInit) <- lift getInput

       L sp tok <- tryP (Lexer.lexer False return)

       case sp of

           let typ = if inPrag then TkPragma else classify tok

               RealSrcLoc lStart _ = srcSpanStart sp -- safe since @sp@ is real

               (spaceBStr, bStart) = spanPosition lInit lStart bInit

   , collapseControl

   ) where

 import GHC.Types.Name (getOccString, isValOcc, nameOccName)

 import GHC.Unit.Module (Module, ModuleName, moduleName, moduleNameString)

 import Text.XHtml hiding (name, p, quote, title)

         case span_ of

           RealSrcSpan span__ _ ->

             show $ srcSpanStartLine span__

           UnhelpfulSpan _ -> ""

     run "" = ""