{-# LANGUAGE BangPatterns     #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE ViewPatterns     #-}
{-# OPTIONS_GHC -Wwarn #-}
  -----------------------------------------------------------------------------
-- |
-- Module      :  Haddock.Interface.LexParseRn
-- Copyright   :  (c) Isaac Dupree 2009,
--                    Mateusz Kowalczyk 2013
-- License     :  BSD-like
--
-- Maintainer  :  haddock@projects.haskell.org
-- Stability   :  experimental
-- Portability :  portable
-----------------------------------------------------------------------------
module Haddock.Interface.LexParseRn
  ( processDocString
  , processDocStringParas
  , processDocStringsParas
  , processModuleHeader
  ) where

import Control.Arrow
import Control.Monad
import Control.Monad.State.Strict
import Data.Functor
import Data.List ((\\), maximumBy)
import Data.Ord
import qualified Data.Set as Set
import GHC
import GHC.Data.EnumSet as EnumSet
import GHC.Data.FastString ( unpackFS )
import GHC.Driver.Ppr ( showPpr, showSDoc )
import GHC.Driver.Session
import GHC.Parser.PostProcess
import GHC.Types.Avail
import GHC.Types.Name
import GHC.Types.Name.Reader
import GHC.Types.Name.Set
import GHC.Utils.Misc ((<||>))
import GHC.Utils.Outputable (Outputable)
import Haddock.Interface.ParseModuleHeader
import Haddock.Parser
import Haddock.Types
import qualified GHC.LanguageExtensions as LangExt

processDocStringsParas
  :: MonadIO m
  => DynFlags
  -> Maybe Package
  -> [HsDoc GhcRn]
  -> IfM m (MDoc Name)
processDocStringsParas :: forall (m :: * -> *).
MonadIO m =>
DynFlags -> Maybe Package -> [HsDoc GhcRn] -> IfM m (MDoc Name)
processDocStringsParas DynFlags
dflags Maybe Package
pkg [HsDoc GhcRn]
hdss =
  (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (MDoc Name)
forall (f :: * -> *) a b c d.
Functor f =>
(DocH a b -> f (DocH c d)) -> MetaDoc a b -> f (MetaDoc c d)
overDocF (DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rename DynFlags
dflags (Renamer
 -> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a b. (a -> b) -> a -> b
$ WithHsDocIdentifiers [HsDocString] GhcRn -> Renamer
forall a. WithHsDocIdentifiers a GhcRn -> Renamer
hsDocRenamer WithHsDocIdentifiers [HsDocString] GhcRn
hds) (MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (MDoc Name))
-> MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (MDoc Name)
forall a b. (a -> b) -> a -> b
$ DynFlags
-> Maybe Package
-> Package
-> MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
forall mod.
DynFlags
-> Maybe Package -> Package -> MetaDoc mod (Wrap NsRdrName)
parseParas DynFlags
dflags Maybe Package
pkg ([HsDocString] -> Package
renderHsDocStrings ([HsDocString] -> Package) -> [HsDocString] -> Package
forall a b. (a -> b) -> a -> b
$ WithHsDocIdentifiers [HsDocString] GhcRn -> [HsDocString]
forall a pass. WithHsDocIdentifiers a pass -> a
hsDocString WithHsDocIdentifiers [HsDocString] GhcRn
hds)
  where
    hds :: WithHsDocIdentifiers [HsDocString] GhcRn
    hds :: WithHsDocIdentifiers [HsDocString] GhcRn
hds = [HsDocString]
-> [Located (IdP GhcRn)]
-> WithHsDocIdentifiers [HsDocString] GhcRn
forall a pass.
a -> [Located (IdP pass)] -> WithHsDocIdentifiers a pass
WithHsDocIdentifiers ((HsDoc GhcRn -> HsDocString) -> [HsDoc GhcRn] -> [HsDocString]
forall a b. (a -> b) -> [a] -> [b]
map HsDoc GhcRn -> HsDocString
forall a pass. WithHsDocIdentifiers a pass -> a
hsDocString [HsDoc GhcRn]
hdss) ((HsDoc GhcRn -> [Located Name]) -> [HsDoc GhcRn] -> [Located Name]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap HsDoc GhcRn -> [Located (IdP GhcRn)]
HsDoc GhcRn -> [Located Name]
forall a pass. WithHsDocIdentifiers a pass -> [Located (IdP pass)]
hsDocIdentifiers [HsDoc GhcRn]
hdss)

processDocStringParas
  :: MonadIO m
  => DynFlags
  -> Maybe Package
  -> (HsDoc GhcRn)
  -> IfM m (MDoc Name)
processDocStringParas :: forall (m :: * -> *).
MonadIO m =>
DynFlags -> Maybe Package -> HsDoc GhcRn -> IfM m (MDoc Name)
processDocStringParas DynFlags
dflags Maybe Package
pkg HsDoc GhcRn
hds =
  (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (MDoc Name)
forall (f :: * -> *) a b c d.
Functor f =>
(DocH a b -> f (DocH c d)) -> MetaDoc a b -> f (MetaDoc c d)
overDocF (DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rename DynFlags
dflags (Renamer
 -> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a b. (a -> b) -> a -> b
$ HsDoc GhcRn -> Renamer
forall a. WithHsDocIdentifiers a GhcRn -> Renamer
hsDocRenamer HsDoc GhcRn
hds) (MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (MDoc Name))
-> MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (MDoc Name)
forall a b. (a -> b) -> a -> b
$ DynFlags
-> Maybe Package
-> Package
-> MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
forall mod.
DynFlags
-> Maybe Package -> Package -> MetaDoc mod (Wrap NsRdrName)
parseParas DynFlags
dflags Maybe Package
pkg (HsDocString -> Package
renderHsDocString (HsDocString -> Package) -> HsDocString -> Package
forall a b. (a -> b) -> a -> b
$ HsDoc GhcRn -> HsDocString
forall a pass. WithHsDocIdentifiers a pass -> a
hsDocString HsDoc GhcRn
hds)

processDocString
  :: MonadIO m
  => DynFlags
  -> (HsDoc GhcRn)
  -> IfM m (Doc Name)
processDocString :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> HsDoc GhcRn
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
processDocString DynFlags
dflags HsDoc GhcRn
hds =
  DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rename DynFlags
dflags (HsDoc GhcRn -> Renamer
forall a. WithHsDocIdentifiers a GhcRn -> Renamer
hsDocRenamer HsDoc GhcRn
hds) (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a b. (a -> b) -> a -> b
$ DynFlags
-> Package -> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
forall mod. DynFlags -> Package -> DocH mod (Wrap NsRdrName)
parseString DynFlags
dflags (HsDocString -> Package
renderHsDocString (HsDocString -> Package) -> HsDocString -> Package
forall a b. (a -> b) -> a -> b
$ HsDoc GhcRn -> HsDocString
forall a pass. WithHsDocIdentifiers a pass -> a
hsDocString HsDoc GhcRn
hds)

processModuleHeader
  :: MonadIO m
  => DynFlags
  -> Maybe Package
  -> SafeHaskellMode
  -> Maybe Language
  -> EnumSet LangExt.Extension
  -> Maybe (HsDoc GhcRn)
  -> IfM m (HaddockModInfo Name, Maybe (MDoc Name))
processModuleHeader :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Maybe Package
-> SafeHaskellMode
-> Maybe Language
-> EnumSet Extension
-> Maybe (HsDoc GhcRn)
-> IfM m (HaddockModInfo Name, Maybe (MDoc Name))
processModuleHeader DynFlags
dflags Maybe Package
pkgName SafeHaskellMode
safety Maybe Language
mayLang EnumSet Extension
extSet Maybe (HsDoc GhcRn)
mayStr = do
  (hmi, doc) <-
    case Maybe (HsDoc GhcRn)
mayStr of
      Maybe (HsDoc GhcRn)
Nothing -> (HaddockModInfo Name, Maybe (MDoc Name))
-> IfM m (HaddockModInfo Name, Maybe (MDoc Name))
forall a. a -> IfM m a
forall (m :: * -> *) a. Monad m => a -> m a
return (HaddockModInfo Name, Maybe (MDoc Name))
forall {a} {a}. (HaddockModInfo a, Maybe a)
failure
      Just HsDoc GhcRn
hsDoc -> do
        let str :: Package
str = HsDocString -> Package
renderHsDocString (HsDocString -> Package) -> HsDocString -> Package
forall a b. (a -> b) -> a -> b
$ HsDoc GhcRn -> HsDocString
forall a pass. WithHsDocIdentifiers a pass -> a
hsDocString HsDoc GhcRn
hsDoc
            (HaddockModInfo NsRdrName
hmi, MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
doc) = DynFlags
-> Maybe Package
-> Package
-> (HaddockModInfo NsRdrName,
    MetaDoc (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
parseModuleHeader DynFlags
dflags Maybe Package
pkgName Package
str
            renamer :: Renamer
renamer = HsDoc GhcRn -> Renamer
forall a. WithHsDocIdentifiers a GhcRn -> Renamer
hsDocRenamer HsDoc GhcRn
hsDoc
        !descr <- case HaddockModInfo NsRdrName
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
forall name. HaddockModInfo name -> Maybe (Doc name)
hmi_description HaddockModInfo NsRdrName
hmi of
                    Just DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
hmi_descr -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> Maybe a
Just (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rename DynFlags
dflags Renamer
renamer DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
hmi_descr
                    Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
Nothing        -> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. Maybe a
Nothing
        let hmi' = HaddockModInfo NsRdrName
hmi { hmi_description = descr }
        doc'  <- overDocF (rename dflags renamer) doc
        return (hmi', Just doc')

  let flags :: [LangExt.Extension]
      -- We remove the flags implied by the language setting and we display the language instead
      flags = EnumSet Extension -> [Extension]
forall a. Enum a => EnumSet a -> [a]
EnumSet.toList EnumSet Extension
extSet [Extension] -> [Extension] -> [Extension]
forall a. Eq a => [a] -> [a] -> [a]
\\ Maybe Language -> [Extension]
languageExtensions Maybe Language
mayLang
  return
    (hmi { hmi_safety = Just $ showPpr dflags safety
         , hmi_language = language dflags
         , hmi_extensions = flags
         }
    , doc
    )
  where
    failure :: (HaddockModInfo a, Maybe a)
failure = (HaddockModInfo a
forall a. HaddockModInfo a
emptyHaddockModInfo, Maybe a
forall a. Maybe a
Nothing)

traverseSnd :: (Traversable t, Applicative f) => (a -> f b) -> t (x, a) -> f (t (x, b))
traverseSnd :: forall (t :: * -> *) (f :: * -> *) a b x.
(Traversable t, Applicative f) =>
(a -> f b) -> t (x, a) -> f (t (x, b))
traverseSnd a -> f b
f = ((x, a) -> f (x, b)) -> t (x, a) -> f (t (x, b))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> t a -> f (t b)
traverse (\(x
x, a
a) ->
                             (\b
b -> (x
x, b
b)) (b -> (x, b)) -> f b -> f (x, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a)

-- | Takes a 'GlobalRdrEnv' which (hopefully) contains all the
-- definitions and a parsed comment and we attempt to make sense of
-- where the identifiers in the comment point to. We're in effect
-- trying to convert 'RdrName's to 'Name's, with some guesswork and
-- fallbacks in case we can't locate the identifiers.
--
-- See the comments in the source for implementation commentary.
rename
  :: MonadIO m
  => DynFlags
  -> Renamer
  -> Doc NsRdrName
  -> IfM m (Doc Name)
rename :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Renamer
-> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rename DynFlags
dflags Renamer
renamer = DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn
  where
    rn :: MonadIO m => Doc NsRdrName -> IfM m (Doc Name)
    rn :: forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
d = case DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
d of
      DocAppend DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
a DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
b -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id -> DocH mod id -> DocH mod id
DocAppend (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM
     m
     (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
      -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
a IfM
  m
  (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
   -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a b. IfM m (a -> b) -> IfM m a -> IfM m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
b
      DocParagraph DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
p -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id -> DocH mod id
DocParagraph (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
p
      DocIdentifier Wrap NsRdrName
i -> do
        let NsRdrName Namespace
ns RdrName
x = Wrap NsRdrName -> NsRdrName
forall n. Wrap n -> n
unwrap Wrap NsRdrName
i
            occ :: OccName
occ = RdrName -> OccName
rdrNameOcc RdrName
x
        let valueNsChoices :: NameSpace -> Bool
valueNsChoices
              | OccName -> Bool
isDataOcc OccName
occ = NameSpace -> Bool
isDataConNameSpace
              | Bool
otherwise = NameSpace -> Bool
isTermVarOrFieldNameSpace
            typeNsChoices :: NameSpace -> Bool
typeNsChoices
              | OccName -> Bool
isDataOcc OccName
occ = NameSpace -> Bool
isTcClsNameSpace
              | OccName -> Bool
isSymOcc OccName
occ = NameSpace -> Bool
isTcClsNameSpace
              | Bool
otherwise = NameSpace -> Bool
isTvNameSpace
        -- Generate the choices for the possible kind of thing this
        -- is. We narrow down the possibilities with the namespace (if
        -- there is one).
        let choices :: NameSpace -> Bool
choices = case Namespace
ns of
                        Namespace
Value -> NameSpace -> Bool
valueNsChoices
                        Namespace
Type  -> NameSpace -> Bool
typeNsChoices
                        Namespace
None  -> NameSpace -> Bool
valueNsChoices (NameSpace -> Bool) -> (NameSpace -> Bool) -> NameSpace -> Bool
forall (f :: * -> *). Applicative f => f Bool -> f Bool -> f Bool
<||> NameSpace -> Bool
typeNsChoices
        case Renamer
renamer (DynFlags -> RdrName -> Package
forall a. Outputable a => DynFlags -> a -> Package
showPpr DynFlags
dflags RdrName
x) NameSpace -> Bool
choices of
          [] ->  case Namespace
ns of
            Namespace
Type -> DynFlags
-> Namespace
-> Wrap RdrName
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *) a.
MonadIO m =>
DynFlags -> Namespace -> Wrap RdrName -> IfM m (Doc a)
outOfScope DynFlags
dflags Namespace
ns (Wrap NsRdrName
i Wrap NsRdrName -> RdrName -> Wrap RdrName
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> RdrName -> NameSpace -> RdrName
setRdrNameSpace RdrName
x NameSpace
tcName)
            Namespace
_ -> DynFlags
-> Namespace
-> Wrap RdrName
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *) a.
MonadIO m =>
DynFlags -> Namespace -> Wrap RdrName -> IfM m (Doc a)
outOfScope DynFlags
dflags Namespace
ns (Wrap NsRdrName
i Wrap NsRdrName -> RdrName -> Wrap RdrName
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> RdrName
x)
          [Name
a] -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Wrap Name -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. id -> DocH mod id
DocIdentifier (Wrap Name -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> Wrap Name -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall a b. (a -> b) -> a -> b
$ Wrap NsRdrName
i Wrap NsRdrName -> Name -> Wrap Name
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Name
a)
          -- There are multiple names available.
          [Name]
names -> DynFlags
-> Wrap NsRdrName
-> [Name]
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Wrap NsRdrName
-> [Name]
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
ambiguous DynFlags
dflags Wrap NsRdrName
i [Name]
names

      DocWarning DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
dw -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id -> DocH mod id
DocWarning (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
dw
      DocEmphasis DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
de -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id -> DocH mod id
DocEmphasis (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
de
      DocBold DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
db -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id -> DocH mod id
DocBold (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
db
      DocMonospaced DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
dm -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id -> DocH mod id
DocMonospaced (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
dm
      DocUnorderedList [DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)]
docs -> [DocH (Wrap (ModuleName, OccName)) (Wrap Name)]
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. [DocH mod id] -> DocH mod id
DocUnorderedList ([DocH (Wrap (ModuleName, OccName)) (Wrap Name)]
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m [DocH (Wrap (ModuleName, OccName)) (Wrap Name)]
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> [DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)]
-> IfM m [DocH (Wrap (ModuleName, OccName)) (Wrap Name)]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn [DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)]
docs
      DocOrderedList [(Int, DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))]
docs -> [(Int, DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. [(Int, DocH mod id)] -> DocH mod id
DocOrderedList ([(Int, DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m [(Int, DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> [(Int, DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))]
-> IfM m [(Int, DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
forall (t :: * -> *) (f :: * -> *) a b x.
(Traversable t, Applicative f) =>
(a -> f b) -> t (x, a) -> f (t (x, b))
traverseSnd DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn [(Int, DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))]
docs
      DocDefList [(DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName),
  DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))]
list -> [(DocH (Wrap (ModuleName, OccName)) (Wrap Name),
  DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. [(DocH mod id, DocH mod id)] -> DocH mod id
DocDefList ([(DocH (Wrap (ModuleName, OccName)) (Wrap Name),
   DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM
     m
     [(DocH (Wrap (ModuleName, OccName)) (Wrap Name),
       DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName),
  DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
 -> IfM
      m
      (DocH (Wrap (ModuleName, OccName)) (Wrap Name),
       DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> [(DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName),
     DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))]
-> IfM
     m
     [(DocH (Wrap (ModuleName, OccName)) (Wrap Name),
       DocH (Wrap (ModuleName, OccName)) (Wrap Name))]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse (\(DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
a, DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
b) -> (,) (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> (DocH (Wrap (ModuleName, OccName)) (Wrap Name),
     DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM
     m
     (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
      -> (DocH (Wrap (ModuleName, OccName)) (Wrap Name),
          DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
a IfM
  m
  (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
   -> (DocH (Wrap (ModuleName, OccName)) (Wrap Name),
       DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM
     m
     (DocH (Wrap (ModuleName, OccName)) (Wrap Name),
      DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a b. IfM m (a -> b) -> IfM m a -> IfM m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
b) [(DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName),
  DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))]
list
      DocCodeBlock DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
dcb -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id -> DocH mod id
DocCodeBlock (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
dcb
      DocIdentifierUnchecked Wrap (ModuleName, OccName)
x -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Wrap (ModuleName, OccName)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. mod -> DocH mod id
DocIdentifierUnchecked Wrap (ModuleName, OccName)
x)
      DocModule (ModLink Package
m Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
l) -> ModLink (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. ModLink (DocH mod id) -> DocH mod id
DocModule (ModLink (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
    -> ModLink (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Package
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> ModLink (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall id. Package -> Maybe id -> ModLink id
ModLink Package
m (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
-> IfM m (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
l
      DocHyperlink (Hyperlink Package
u Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
l) -> Hyperlink (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Hyperlink (DocH mod id) -> DocH mod id
DocHyperlink (Hyperlink (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
    -> Hyperlink (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Package
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> Hyperlink (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall id. Package -> Maybe id -> Hyperlink id
Hyperlink Package
u (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
-> IfM m (Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn Maybe (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
l
      DocPic Picture
str -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Picture -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Picture -> DocH mod id
DocPic Picture
str)
      DocMathInline Package
str -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Package -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Package -> DocH mod id
DocMathInline Package
str)
      DocMathDisplay Package
str -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Package -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Package -> DocH mod id
DocMathDisplay Package
str)
      DocAName Package
str -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Package -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Package -> DocH mod id
DocAName Package
str)
      DocProperty Package
p -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Package -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Package -> DocH mod id
DocProperty Package
p)
      DocExamples [Example]
e -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Example] -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. [Example] -> DocH mod id
DocExamples [Example]
e)
      DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
DocEmpty -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. DocH mod id
DocEmpty)
      DocString Package
str -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Package -> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Package -> DocH mod id
DocString Package
str)
      DocHeader (Header Int
l DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
t) -> Header (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Header (DocH mod id) -> DocH mod id
DocHeader (Header (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
    -> Header (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
-> Header (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall id. Int -> id -> Header id
Header Int
l (DocH (Wrap (ModuleName, OccName)) (Wrap Name)
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
t
      DocTable Table (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
t -> Table (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> DocH (Wrap (ModuleName, OccName)) (Wrap Name)
forall mod id. Table (DocH mod id) -> DocH mod id
DocTable (Table (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
 -> DocH (Wrap (ModuleName, OccName)) (Wrap Name))
-> IfM m (Table (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
 -> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
-> Table (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
-> IfM m (Table (DocH (Wrap (ModuleName, OccName)) (Wrap Name)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Table a -> f (Table b)
traverse DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
forall (m :: * -> *).
MonadIO m =>
DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName)
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
rn Table (DocH (Wrap (ModuleName, OccName)) (Wrap NsRdrName))
t

-- | Wrap an identifier that's out of scope (i.e. wasn't found in
-- 'GlobalReaderEnv' during 'rename') in an appropriate doc. Currently
-- we simply monospace the identifier in most cases except when the
-- identifier is qualified: if the identifier is qualified then we can
-- still try to guess and generate anchors accross modules but the
-- users shouldn't rely on this doing the right thing. See tickets
-- #253 and #375 on the confusion this causes depending on which
-- default we pick in 'rename'.
outOfScope :: MonadIO m => DynFlags -> Namespace -> Wrap RdrName -> IfM m (Doc a)
outOfScope :: forall (m :: * -> *) a.
MonadIO m =>
DynFlags -> Namespace -> Wrap RdrName -> IfM m (Doc a)
outOfScope DynFlags
dflags Namespace
ns Wrap RdrName
x =
    case Wrap RdrName -> RdrName
forall n. Wrap n -> n
unwrap Wrap RdrName
x of
      Unqual OccName
occ -> Wrap OccName -> IfM m (Doc a)
forall (m :: * -> *) a mod id.
(MonadIO m, Outputable a) =>
Wrap a -> IfM m (DocH mod id)
warnAndMonospace (Wrap RdrName
x Wrap RdrName -> OccName -> Wrap OccName
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> OccName
occ)
      Qual ModuleName
mdl OccName
occ -> Doc a -> IfM m (Doc a)
forall a. a -> IfM m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Wrap (ModuleName, OccName) -> Doc a
forall mod id. mod -> DocH mod id
DocIdentifierUnchecked (Wrap RdrName
x Wrap RdrName -> (ModuleName, OccName) -> Wrap (ModuleName, OccName)
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> (ModuleName
mdl, OccName
occ)))
      Orig Module
_ OccName
occ -> Wrap OccName -> IfM m (Doc a)
forall (m :: * -> *) a mod id.
(MonadIO m, Outputable a) =>
Wrap a -> IfM m (DocH mod id)
warnAndMonospace (Wrap RdrName
x Wrap RdrName -> OccName -> Wrap OccName
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> OccName
occ)
      Exact Name
name -> Wrap Name -> IfM m (Doc a)
forall (m :: * -> *) a mod id.
(MonadIO m, Outputable a) =>
Wrap a -> IfM m (DocH mod id)
warnAndMonospace (Wrap RdrName
x Wrap RdrName -> Name -> Wrap Name
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Name
name)  -- Shouldn't happen since x is out of scope
  where
    prefix :: Package
prefix =
      case Namespace
ns of
        Namespace
Value -> Package
"the value "
        Namespace
Type -> Package
"the type "
        Namespace
None -> Package
""

    warnAndMonospace :: (MonadIO m, Outputable a) => Wrap a -> IfM m (DocH mod id)
    warnAndMonospace :: forall (m :: * -> *) a mod id.
(MonadIO m, Outputable a) =>
Wrap a -> IfM m (DocH mod id)
warnAndMonospace Wrap a
a = do
      let a' :: Package
a' = (a -> Package) -> Wrap a -> Package
forall a. (a -> Package) -> Wrap a -> Package
showWrapped (DynFlags -> a -> Package
forall a. Outputable a => DynFlags -> a -> Package
showPpr DynFlags
dflags) Wrap a
a

      -- If we have already warned for this identifier, don't warn again
      firstWarn <- Package -> Set Package -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.notMember Package
a' (Set Package -> Bool) -> IfM m (Set Package) -> IfM m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (IfEnv m -> Set Package) -> IfM m (Set Package)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets IfEnv m -> Set Package
forall (m :: * -> *). IfEnv m -> Set Package
ifeOutOfScopeNames
      when firstWarn $ do
        warn $
          "Warning: " ++ prefix ++ "'" ++ a' ++ "' is out of scope.\n" ++
          "    If you qualify the identifier, haddock can try to link it anyway."
        modify' (\IfEnv m
env -> IfEnv m
env { ifeOutOfScopeNames = Set.insert a' (ifeOutOfScopeNames env) })

      pure (monospaced a')
    monospaced :: Package -> DocH mod id
monospaced = DocH mod id -> DocH mod id
forall mod id. DocH mod id -> DocH mod id
DocMonospaced (DocH mod id -> DocH mod id)
-> (Package -> DocH mod id) -> Package -> DocH mod id
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Package -> DocH mod id
forall mod id. Package -> DocH mod id
DocString

-- | Handle ambiguous identifiers.
--
-- Prefers local names primarily and type constructors or class names secondarily.
--
-- Emits a warning if the 'GlobalRdrElts's don't belong to the same type or class.
ambiguous
  :: MonadIO m
  => DynFlags
  -> Wrap NsRdrName
  -> [Name] -- ^ More than one @gre@s sharing the same `RdrName` above.
  -> IfM m (Doc Name)
ambiguous :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> Wrap NsRdrName
-> [Name]
-> IfM m (DocH (Wrap (ModuleName, OccName)) (Wrap Name))
ambiguous DynFlags
dflags Wrap NsRdrName
x [Name]
names = do
    let noChildren :: [Name]
noChildren = (AvailInfo -> Name) -> [AvailInfo] -> [Name]
forall a b. (a -> b) -> [a] -> [b]
map AvailInfo -> Name
availName ([AvailInfo] -> [AvailInfo]
nubAvails ((Name -> AvailInfo) -> [Name] -> [AvailInfo]
forall a b. (a -> b) -> [a] -> [b]
map Name -> AvailInfo
Avail [Name]
names))
        dflt :: Name
dflt = (Name -> Name -> Ordering) -> [Name] -> Name
forall (t :: * -> *) a.
Foldable t =>
(a -> a -> Ordering) -> t a -> a
maximumBy ((Name -> (Bool, Bool)) -> Name -> Name -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing (Name -> Bool
isLocalName (Name -> Bool) -> (Name -> Bool) -> Name -> (Bool, Bool)
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& Name -> Bool
isTyConName)) [Name]
noChildren
        nameStr :: Package
nameStr = DynFlags -> Wrap NsRdrName -> Package
showNsRdrName DynFlags
dflags Wrap NsRdrName
x
        msg :: Package
msg = Package
"Warning: " Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Package
nameStr Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Package
" is ambiguous. It is defined\n" Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++
              (Name -> Package) -> [Name] -> Package
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\Name
n -> Package
"    * " Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Name -> Package
defnLoc Name
n Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Package
"\n") [Name]
names Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++
              Package
"    You may be able to disambiguate the identifier by qualifying it or\n" Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++
              Package
"    by specifying the type/value namespace explicitly.\n" Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++
              Package
"    Defaulting to the one defined " Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Name -> Package
defnLoc Name
dflt

    -- TODO: Once we have a syntax for namespace qualification (#667) we may also
    -- want to emit a warning when an identifier is a data constructor for a type
    -- of the same name, but not the only constructor.
    -- For example, for @data D = C | D@, someone may want to reference the @D@
    -- constructor.

    -- If we have already warned for this name, do not warn again
    firstWarn <- Package -> Set Package -> Bool
forall a. Ord a => a -> Set a -> Bool
Set.notMember Package
nameStr (Set Package -> Bool) -> IfM m (Set Package) -> IfM m Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (IfEnv m -> Set Package) -> IfM m (Set Package)
forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
gets IfEnv m -> Set Package
forall (m :: * -> *). IfEnv m -> Set Package
ifeAmbiguousNames
    when (length noChildren > 1 && firstWarn) $ do
      warn msg
      modify' (\IfEnv m
env -> IfEnv m
env { ifeAmbiguousNames = Set.insert nameStr (ifeAmbiguousNames env) })

    pure (DocIdentifier (x $> dflt))
  where
    isLocalName :: Name -> Bool
isLocalName (Name -> SrcLoc
nameSrcLoc -> RealSrcLoc {}) = Bool
True
    isLocalName Name
_ = Bool
False
    defnLoc :: Name -> Package
defnLoc = DynFlags -> SDoc -> Package
showSDoc DynFlags
dflags (SDoc -> Package) -> (Name -> SDoc) -> Name -> Package
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> SDoc
pprNameDefnLoc

-- | Printable representation of a wrapped and namespaced name
showNsRdrName :: DynFlags -> Wrap NsRdrName -> String
showNsRdrName :: DynFlags -> Wrap NsRdrName -> Package
showNsRdrName DynFlags
dflags = (\Package
p Package
i -> Package
p Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Package
"'" Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Package
i Package -> Package -> Package
forall a. [a] -> [a] -> [a]
++ Package
"'") (Package -> Package -> Package)
-> (Wrap NsRdrName -> Package)
-> Wrap NsRdrName
-> Package
-> Package
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Wrap NsRdrName -> Package
prefix (Wrap NsRdrName -> Package -> Package)
-> (Wrap NsRdrName -> Package) -> Wrap NsRdrName -> Package
forall a b.
(Wrap NsRdrName -> a -> b)
-> (Wrap NsRdrName -> a) -> Wrap NsRdrName -> b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Wrap NsRdrName -> Package
ident
  where
    ident :: Wrap NsRdrName -> Package
ident = (NsRdrName -> Package) -> Wrap NsRdrName -> Package
forall a. (a -> Package) -> Wrap a -> Package
showWrapped (DynFlags -> RdrName -> Package
forall a. Outputable a => DynFlags -> a -> Package
showPpr DynFlags
dflags (RdrName -> Package)
-> (NsRdrName -> RdrName) -> NsRdrName -> Package
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NsRdrName -> RdrName
rdrName)
    prefix :: Wrap NsRdrName -> Package
prefix = Namespace -> Package
renderNs (Namespace -> Package)
-> (Wrap NsRdrName -> Namespace) -> Wrap NsRdrName -> Package
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NsRdrName -> Namespace
namespace (NsRdrName -> Namespace)
-> (Wrap NsRdrName -> NsRdrName) -> Wrap NsRdrName -> Namespace
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Wrap NsRdrName -> NsRdrName
forall n. Wrap n -> n
unwrap

hsDocRenamer :: WithHsDocIdentifiers a GhcRn -> Renamer
hsDocRenamer :: forall a. WithHsDocIdentifiers a GhcRn -> Renamer
hsDocRenamer WithHsDocIdentifiers a GhcRn
hsDoc = \Package
s NameSpace -> Bool
cands -> NameSet -> [Name]
nameSetElemsStable (NameSet -> [Name]) -> NameSet -> [Name]
forall a b. (a -> b) -> a -> b
$ (Name -> Bool) -> NameSet -> NameSet
filterNameSet (Package -> (NameSpace -> Bool) -> Name -> Bool
forall {p}.
HasOccName p =>
Package -> (NameSpace -> Bool) -> p -> Bool
nameMatches Package
s NameSpace -> Bool
cands) NameSet
env
  where
    !env :: NameSet
env = WithHsDocIdentifiers a GhcRn -> NameSet
forall a. WithHsDocIdentifiers a GhcRn -> NameSet
hsDocIds WithHsDocIdentifiers a GhcRn
hsDoc
    nameMatches :: Package -> (NameSpace -> Bool) -> p -> Bool
nameMatches Package
s NameSpace -> Bool
ok_ns p
n =
      let occ :: OccName
occ = p -> OccName
forall name. HasOccName name => name -> OccName
occName p
n
      in NameSpace -> Bool
ok_ns (OccName -> NameSpace
occNameSpace OccName
occ) Bool -> Bool -> Bool
&& Package
s Package -> Package -> Bool
forall a. Eq a => a -> a -> Bool
== FastString -> Package
unpackFS (OccName -> FastString
occNameFS OccName
occ)