aboutsummaryrefslogtreecommitdiff
path: root/src/Haddock/Interface/Create.hs
blob: 94c2a7e70183f53b5e8d441d9c659cceb91f584d (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
-----------------------------------------------------------------------------
-- |
-- Module      :  Haddock.Interface.Create
-- Copyright   :  (c) Simon Marlow 2003-2006,
--                    David Waern  2006-2009
-- License     :  BSD-like
--
-- Maintainer  :  haddock@projects.haskell.org
-- Stability   :  experimental
-- Portability :  portable
-----------------------------------------------------------------------------
module Haddock.Interface.Create (createInterface) where


import Haddock.Types
import Haddock.Options
import Haddock.GhcUtils
import Haddock.Utils
import Haddock.Convert
import Haddock.Interface.LexParseRn
import Haddock.Interface.ExtractFnArgDocs

import qualified Data.Map as Map
import Data.Map (Map)
import Data.List
import Data.Maybe
import Data.Ord
import Control.Monad
import qualified Data.Traversable as Traversable

import GHC hiding (flags)
import HscTypes
import Name
import Bag
import RdrName (GlobalRdrEnv)


-- | Use a 'TypecheckedModule' to produce an 'Interface'.
-- To do this, we need access to already processed modules in the topological
-- sort. That's what's in the 'IfaceMap'.
createInterface :: TypecheckedModule -> [Flag] -> IfaceMap -> InstIfaceMap
                -> ErrMsgGhc Interface
createInterface tm flags modMap instIfaceMap = do

  let ms                  = pm_mod_summary . tm_parsed_module $ tm
      mi                  = moduleInfo tm
      mdl                 = ms_mod ms
      dflags              = ms_hspp_opts ms
      instances           = modInfoInstances mi
      exportedNames       = modInfoExports mi
      -- XXX: confirm always a Just.
      Just (group_, _, optExports, optDocHeader) = renamedSource tm

  -- The pattern-match should not fail, because createInterface is only
  -- done on loaded modules.
  Just gre <- liftGhcToErrMsgGhc $ lookupLoadedHomeModuleGRE (moduleName mdl)

  opts0 <- liftErrMsg $ mkDocOpts (haddockOptions dflags) flags mdl
  let opts
        | Flag_IgnoreAllExports `elem` flags = OptIgnoreExports : opts0
        | otherwise = opts0

  (info, mbDoc)    <- liftErrMsg $ lexParseRnHaddockModHeader dflags gre optDocHeader
  decls0           <- liftErrMsg $ declInfos dflags gre (topDecls group_)

  let localInsts     = filter (nameIsLocalOrFrom mdl . getName) instances
      declDocs       = [ (decl, doc) | (L _ decl, (Just doc, _), _) <- decls0 ]
      instanceDocMap = mkInstanceDocMap localInsts declDocs

      decls         = filterOutInstances decls0
      declMap       = mkDeclMap decls
      exports0      = fmap (reverse . map unLoc) optExports
      exports
        | OptIgnoreExports `elem` opts = Nothing
        | otherwise = exports0

  liftErrMsg $ warnAboutFilteredDecls mdl decls0

  exportItems <- mkExportItems modMap mdl gre exportedNames decls declMap
                               exports instances instIfaceMap dflags

  let visibleNames = mkVisibleNames exportItems opts

  -- measure haddock documentation coverage.
  let
    prunedExportItems0 = pruneExportItems exportItems
    haddockable = 1 + length exportItems -- module + exports
    haddocked = (if isJust mbDoc then 1 else 0) + length prunedExportItems0
    coverage = (haddockable, haddocked)

  -- prune the export list to just those declarations that have
  -- documentation, if the 'prune' option is on.
  let
    prunedExportItems
      | OptPrune `elem` opts = prunedExportItems0
      | otherwise = exportItems

  return Interface {
    ifaceMod             = mdl,
    ifaceOrigFilename    = msHsFilePath ms,
    ifaceInfo            = info,
    ifaceDoc             = mbDoc,
    ifaceRnDoc           = Nothing,
    ifaceOptions         = opts,
    ifaceRnDocMap        = Map.empty,
    ifaceExportItems     = prunedExportItems,
    ifaceRnExportItems   = [],
    ifaceExports         = exportedNames,
    ifaceVisibleExports  = visibleNames,
    ifaceDeclMap         = declMap,
    ifaceSubMap          = mkSubMap declMap exportedNames,
    ifaceInstances       = instances,
    ifaceInstanceDocMap  = instanceDocMap,
    ifaceHaddockCoverage = coverage
  }


-------------------------------------------------------------------------------
-- Doc options
--
-- Haddock options that are embedded in the source file
-------------------------------------------------------------------------------


mkDocOpts :: Maybe String -> [Flag] -> Module -> ErrMsgM [DocOption]
mkDocOpts mbOpts flags mdl = do
  opts <- case mbOpts of
    Just opts -> case words $ replace ',' ' ' opts of
      [] -> tell ["No option supplied to DOC_OPTION/doc_option"] >> return []
      xs -> liftM catMaybes (mapM parseOption xs)
    Nothing -> return []
  if Flag_HideModule (moduleString mdl) `elem` flags
    then return $ OptHide : opts
    else return opts


parseOption :: String -> ErrMsgM (Maybe DocOption)
parseOption "hide"           = return (Just OptHide)
parseOption "prune"          = return (Just OptPrune)
parseOption "ignore-exports" = return (Just OptIgnoreExports)
parseOption "not-home"       = return (Just OptNotHome)
parseOption other = tell ["Unrecognised option: " ++ other] >> return Nothing


--------------------------------------------------------------------------------
-- Declarations
--------------------------------------------------------------------------------


mkInstanceDocMap :: [Instance] -> [(HsDecl name, doc)] -> Map Name doc
mkInstanceDocMap instances decls =
  -- We relate Instances to InstDecls using the SrcSpans buried inside them.
  -- That should work for normal user-written instances (from looking at GHC
  -- sources). We can assume that commented instances are user-written.
  -- This lets us relate Names (from Instances) to comments (associated
  -- with InstDecls).
  let docMap = Map.fromList [ (loc, doc)
                            | (InstD (InstDecl (L loc _) _ _ _), doc) <- decls ]

  in Map.fromList [ (name, doc) | inst <- instances
                  , let name = getName inst
                  , Just doc <- [ Map.lookup (getSrcSpan name) docMap ] ]


-- | Make a sub map from a declaration map. Make sure we only include exported
-- names.
mkSubMap :: Map Name DeclInfo -> [Name] -> Map Name [Name]
mkSubMap declMap exports =
  Map.filterWithKey (\k _ -> k `elem` exports) (Map.map filterSubs declMap)
  where
    filterSubs (_, _, subs) = [ sub  | (sub, _) <- subs, sub `elem` exports ]


-- Make a map from names to 'DeclInfo's. Exclude declarations that don't have
-- names (e.g. instances and stand-alone documentation comments). Include
-- subordinate names, but map them to their parent declarations.
mkDeclMap :: [DeclInfo] -> Map Name DeclInfo
mkDeclMap decls = Map.fromList . concat $
  [ decls_ ++ subDecls
  | (parent@(L _ d), doc, subs) <- decls
  , let decls_ = [ (name, (parent, doc, subs)) | name <- getMainDeclBinder d ]
        subDecls = [ (n, (parent, doc', [])) | (n, doc') <- subs ]
  , not (isDocD d), not (isInstD d) ]


declInfos :: DynFlags -> GlobalRdrEnv -> [(Decl, MaybeDocStrings)] -> ErrMsgM [DeclInfo]
declInfos dflags gre decls =
  forM decls $ \(parent@(L _ d), mbDocString) -> do
            mbDoc <- lexParseRnHaddockCommentList dflags NormalHaddockComment
                       gre mbDocString
            fnArgsDoc <- fmap (Map.mapMaybe id) $
                Traversable.forM (getDeclFnArgDocs d) $
                \doc -> lexParseRnHaddockComment dflags NormalHaddockComment gre doc

            let subs_ = subordinates d
            subs <- forM subs_ $ \(subName, mbSubDocStr, subFnArgsDocStr) -> do
                mbSubDoc <- lexParseRnHaddockCommentList dflags NormalHaddockComment
                              gre mbSubDocStr
                subFnArgsDoc <- fmap (Map.mapMaybe id) $
                  Traversable.forM subFnArgsDocStr $
                  \doc -> lexParseRnHaddockComment dflags NormalHaddockComment gre doc
                return (subName, (mbSubDoc, subFnArgsDoc))

            return (parent, (mbDoc, fnArgsDoc), subs)


-- | If you know the HsDecl can't contain any docs
-- (e.g., it was loaded from a .hi file and you don't have a .haddock file
-- to help you find out about the subs or docs)
-- then you can use this to get its subs.
subordinatesWithNoDocs :: HsDecl Name -> [(Name, DocForDecl Name)]
subordinatesWithNoDocs decl = map noDocs (subordinates decl)
  where
    -- check the condition... or shouldn't we be checking?
    noDocs (n, doc1, doc2) | null doc1, Map.null doc2
        = (n, noDocForDecl)
    noDocs _ = error ("no-docs thing has docs! " ++ pretty decl)


subordinates :: HsDecl Name -> [(Name, MaybeDocStrings, Map Int HsDocString)]
subordinates (TyClD d) = classDataSubs d
subordinates _ = []


classDataSubs :: TyClDecl Name -> [(Name, MaybeDocStrings, Map Int HsDocString)]
classDataSubs decl
  | isClassDecl decl = classSubs
  | isDataDecl  decl = dataSubs
  | otherwise        = []
  where
    classSubs = [ (name, doc, fnArgsDoc)
                | (L _ d, doc) <- classDecls decl
                , name <- getMainDeclBinder d
                , let fnArgsDoc = getDeclFnArgDocs d ]
    dataSubs  = constrs ++ fields
      where
        cons    = map unL $ tcdCons decl
        -- should we use the type-signature of the constructor
        -- and the docs of the fields to produce fnArgsDoc for the constr,
        -- just in case someone exports it without exporting the type
        -- and perhaps makes it look like a function?  I doubt it.
        constrs = [ (unL $ con_name c, maybeToList $ fmap unL $ con_doc c, Map.empty)
                  | c <- cons ]
        fields  = [ (unL n, maybeToList $ fmap unL doc, Map.empty)
                  | RecCon flds <- map con_details cons
                  , ConDeclField n _ doc <- flds ]


-- All the sub declarations of a class (that we handle), ordered by
-- source location, with documentation attached if it exists.
classDecls :: TyClDecl Name -> [(Decl, MaybeDocStrings)]
classDecls = filterDecls . collectDocs . sortByLoc . declsFromClass


declsFromClass :: TyClDecl a -> [Located (HsDecl a)]
declsFromClass class_ = docs ++ defs ++ sigs ++ ats
  where
    docs = mkDecls tcdDocs DocD class_
    defs = mkDecls (bagToList . tcdMeths) ValD class_
    sigs = mkDecls tcdSigs SigD class_
    ats  = mkDecls tcdATs TyClD class_


-- | The top-level declarations of a module that we care about,
-- ordered by source location, with documentation attached if it exists.
topDecls :: HsGroup Name -> [(Decl, MaybeDocStrings)]
topDecls = filterClasses . filterDecls . collectDocs . sortByLoc . declsFromGroup


filterOutInstances :: [(Located (HsDecl a), b, c)] -> [(Located (HsDecl a), b, c)]
filterOutInstances = filter (\(L _ d, _, _) -> not (isInstD d))


-- | Take all declarations except pragmas, infix decls, rules and value
-- bindings from an 'HsGroup'.
declsFromGroup :: HsGroup Name -> [Decl]
declsFromGroup group_ =
#if MIN_VERSION_ghc(7,0,2)
  mkDecls (concat . hs_tyclds)  TyClD  group_ ++
#else
  mkDecls hs_tyclds             TyClD  group_ ++
#endif
  mkDecls hs_derivds            DerivD group_ ++
  mkDecls hs_defds              DefD   group_ ++
  mkDecls hs_fords              ForD   group_ ++
  mkDecls hs_docs               DocD   group_ ++
  mkDecls hs_instds             InstD  group_ ++
  mkDecls (typesigs . hs_valds) SigD   group_
  where
    typesigs (ValBindsOut _ sigs) = filter isVanillaLSig sigs
    typesigs _ = error "expected ValBindsOut"


-- | Take a field of declarations from a data structure and create HsDecls
-- using the given constructor
mkDecls :: (a -> [Located b]) -> (b -> c) -> a -> [Located c]
mkDecls field con struct = [ L loc (con decl) | L loc decl <- field struct ]


-- | Sort by source location
sortByLoc :: [Located a] -> [Located a]
sortByLoc = sortBy (comparing getLoc)


warnAboutFilteredDecls :: Module -> [(LHsDecl Name, b, c)] -> ErrMsgM ()
warnAboutFilteredDecls mdl decls = do
  let modStr = moduleString mdl
  let typeInstances =
        nub [ tcdName d | (L _ (TyClD d), _, _) <- decls, isFamInstDecl d ]

  unless (null typeInstances) $
    tell [
      "Warning: " ++ modStr ++ ": Instances of type and data "
      ++ "families are not yet supported. Instances of the following families "
      ++ "will be filtered out:\n  " ++ concat (intersperse ", "
      $ map (occNameString . nameOccName) typeInstances) ]

  let instances = nub [ pretty i | (L _ (InstD (InstDecl i _ _ ats)), _, _) <- decls
                                 , not (null ats) ]

  unless (null instances) $
    tell [
      "Warning: " ++ modStr ++ ": We do not support associated types in instances yet. "
      ++ "These instances are affected:\n" ++ concat (intersperse ", " instances) ]


--------------------------------------------------------------------------------
-- Filtering of declarations
--
-- We filter out declarations that we don't intend to handle later.
--------------------------------------------------------------------------------


-- | Filter out declarations that we don't handle in Haddock
filterDecls :: [(Decl, doc)] -> [(Decl, doc)]
filterDecls decls = filter (isHandled . unL . fst) decls
  where
    isHandled (ForD (ForeignImport {})) = True
    isHandled (TyClD {}) = True
    isHandled (InstD {}) = True
    isHandled (SigD d) = isVanillaLSig (reL d)
    -- we keep doc declarations to be able to get at named docs
    isHandled (DocD _) = True
    isHandled _ = False


-- | Go through all class declarations and filter their sub-declarations
filterClasses :: [(Decl, doc)] -> [(Decl, doc)]
filterClasses decls = [ if isClassD d then (L loc (filterClass d), doc) else x
                      | x@(L loc d, doc) <- decls ]
  where
    filterClass (TyClD c) =
      TyClD $ c { tcdSigs = filter isVanillaLSig $ tcdSigs c }
    filterClass _ = error "expected TyClD"


--------------------------------------------------------------------------------
-- Collect docs
--
-- To be able to attach the right Haddock comment to the right declaration,
-- we sort the declarations by their SrcLoc and "collect" the docs for each
-- declaration.
--------------------------------------------------------------------------------

type MaybeDocStrings = [HsDocString]
-- avoid [] because we're appending from the left (quadratic),
-- and avoid adding another package dependency for haddock,
-- so use the difference-list pattern
type MaybeDocStringsFast = MaybeDocStrings -> MaybeDocStrings
docStringEmpty :: MaybeDocStringsFast
docStringEmpty = id
docStringSingleton :: HsDocString -> MaybeDocStringsFast
docStringSingleton = (:)
docStringAppend :: MaybeDocStringsFast -> MaybeDocStringsFast -> MaybeDocStringsFast
docStringAppend = (.)
docStringToList :: MaybeDocStringsFast -> MaybeDocStrings
docStringToList = ($ [])

-- | Collect the docs and attach them to the right declaration.
collectDocs :: [Decl] -> [(Decl, MaybeDocStrings)]
collectDocs = collect Nothing docStringEmpty

collect :: Maybe Decl -> MaybeDocStringsFast -> [Decl] -> [(Decl, MaybeDocStrings)]
collect d doc_so_far [] =
   case d of
        Nothing -> []
        Just d0  -> finishedDoc d0 doc_so_far []

collect d doc_so_far (e:es) =
  case e of
    L _ (DocD (DocCommentNext str)) ->
      case d of
        Nothing -> collect d
                     (docStringAppend doc_so_far (docStringSingleton str))
                     es
        Just d0 -> finishedDoc d0 doc_so_far (collect Nothing
                     (docStringSingleton str)
                     es)

    L _ (DocD (DocCommentPrev str)) -> collect d
                     (docStringAppend doc_so_far (docStringSingleton str))
                     es

    _ -> case d of
      Nothing -> collect (Just e) doc_so_far es
      Just d0 -> finishedDoc d0 doc_so_far (collect (Just e) docStringEmpty es)


-- This used to delete all DocD:s, unless doc was DocEmpty,
-- which I suppose means you could kill a DocCommentNamed
-- by:
--
-- > -- | killer
-- >
-- > -- $victim
--
-- Anyway I accidentally deleted the DocEmpty condition without
-- realizing it was necessary for retaining some DocDs (at least
-- DocCommentNamed), so I'm going to try just not testing any conditions
-- and see if anything breaks.  It really shouldn't break anything
-- to keep more doc decls around, IMHO.
--
-- -Isaac
finishedDoc :: Decl -> MaybeDocStringsFast -> [(Decl, MaybeDocStrings)] -> [(Decl, MaybeDocStrings)]
finishedDoc d doc rest = (d, docStringToList doc) : rest


-- | Build the list of items that will become the documentation, from the
-- export list.  At this point, the list of ExportItems is in terms of
-- original names.
--
-- We create the export items even if the module is hidden, since they
-- might be useful when creating the export items for other modules.
mkExportItems
  :: IfaceMap
  -> Module             -- this module
  -> GlobalRdrEnv
  -> [Name]             -- exported names (orig)
  -> [DeclInfo]
  -> Map Name DeclInfo  -- maps local names to declarations
  -> Maybe [IE Name]
  -> [Instance]
  -> InstIfaceMap
  -> DynFlags
  -> ErrMsgGhc [ExportItem Name]
mkExportItems modMap thisMod gre exportedNames decls declMap
              optExports _ instIfaceMap dflags =
  case optExports of
    Nothing      -> liftErrMsg $ fullContentsOfThisModule dflags gre decls
    Just exports -> liftM (nubBy commaDeclared . concat) $ mapM lookupExport exports
  where
    -- A type signature can have multiple names, like:
    --   foo, bar :: Types..
    -- When going throug the exported names we have to take care to detect such
    -- situations and remove the duplicates.
    commaDeclared (ExportDecl (L _ sig1) _ _ _) (ExportDecl (L _ sig2) _ _ _) =
      getMainDeclBinder sig1 == getMainDeclBinder sig2
    commaDeclared _ _ = False


    lookupExport (IEVar x)             = declWith x
    lookupExport (IEThingAbs t)        = declWith t
    lookupExport (IEThingAll t)        = declWith t
    lookupExport (IEThingWith t _)     = declWith t
    lookupExport (IEModuleContents m)  =
      moduleExports thisMod m dflags gre exportedNames decls modMap instIfaceMap
    lookupExport (IEGroup lev docStr)  = liftErrMsg $
      ifDoc (lexParseRnHaddockComment dflags DocSectionComment gre docStr)
            (\doc -> return [ ExportGroup lev "" doc ])
    lookupExport (IEDoc docStr)        = liftErrMsg $
      ifDoc (lexParseRnHaddockComment dflags NormalHaddockComment gre docStr)
            (\doc -> return [ ExportDoc doc ])
    lookupExport (IEDocNamed str)      = liftErrMsg $
      ifDoc (findNamedDoc str [ unL d | (d,_,_) <- decls ])
            (\docStr ->
            ifDoc (lexParseRnHaddockComment dflags NormalHaddockComment gre docStr)
                  (\doc -> return [ ExportDoc doc ]))


    ifDoc :: (Monad m) => m (Maybe a) -> (a -> m [b]) -> m [b]
    ifDoc parse finish = do
      mbDoc <- parse
      case mbDoc of Nothing -> return []; Just doc -> finish doc


    declWith :: Name -> ErrMsgGhc [ ExportItem Name ]
    declWith t =
      case findDecl t of
        Just (decl, doc, subs) ->
          let declNames = getMainDeclBinder (unL decl)
          in case () of
            _
              -- temp hack: we filter out separately exported ATs, since we haven't decided how
              -- to handle them yet. We should really give an warning message also, and filter the
              -- name out in mkVisibleNames...
              | t `elem` declATs (unL decl)        -> return []

              -- We should not show a subordinate by itself if any of its
              -- parents is also exported. See note [1].
              | not $ t `elem` declNames,
                Just p <- find isExported (parents t $ unL decl) ->
                do liftErrMsg $ tell [
                     "Warning: " ++ moduleString thisMod ++ ": " ++
                     pretty (nameOccName t) ++ " is exported separately but " ++
                     "will be documented under " ++ pretty (nameOccName p) ++
                     ". Consider exporting it together with its parent(s)" ++
                     " for code clarity." ]
                   return []

              -- normal case
              | otherwise -> return [ mkExportDecl t (newDecl, doc, subs) ]
                  where
                    -- Since a single signature might refer to many names, we
                    -- need to filter the ones that are actually exported. This
                    -- requires modifying the type signatures to "hide" the
                    -- names that are not exported.
                    newDecl = case decl of
                      (L loc (SigD sig)) ->
                        L loc . SigD . fromJust $ filterSigNames isExported sig
                        -- fromJust is safe since we already checked in guards
                        -- that 't' is a name declared in this declaration.
                      _                  -> decl
        Nothing -> do
          -- If we can't find the declaration, it must belong to
          -- another package
          mbTyThing <- liftGhcToErrMsgGhc $ lookupName t
          -- show the name as exported as well as the name's
          -- defining module (because the latter is where we
          -- looked for the .hi/.haddock).  It's to help people
          -- debugging after all, so good to show more info.
          let exportInfoString =
                         moduleString thisMod ++ "." ++ getOccString t
                      ++ ": "
                      ++ pretty (nameModule t) ++ "." ++ getOccString t

          case mbTyThing of
            Nothing -> do
              liftErrMsg $ tell
                 ["Warning: Couldn't find TyThing for exported "
                 ++ exportInfoString ++ "; not documenting."]
              -- Is getting to here a bug in Haddock?
              -- Aren't the .hi files always present?
              return [ ExportNoDecl t [] ]
            Just tyThing -> do
              let hsdecl = tyThingToLHsDecl tyThing
              -- This is not the ideal way to implement haddockumentation
              -- for functions/values without explicit type signatures.
              --
              -- However I didn't find an easy way to implement it properly,
              -- and as long as we're using lookupName it is going to find
              -- the types of local inferenced binds.  If we don't check for
              -- this at all, then we'll get the "warning: couldn't find
              -- .haddock" which is wrong.
              --
              -- The reason this is not an ideal implementation
              -- (besides that we take a trip to desugared syntax and back
              -- unnecessarily)
              -- is that Haddock won't be able to detect doc-strings being
              -- attached to such a function, such as,
              --
              -- > -- | this is an identity function
              -- > id a = a
              --
              -- . It's more difficult to say what it ought to mean in cases
              -- where multiple exports are bound at once, like
              --
              -- > -- | comment...
              -- > (a, b) = ...
              --
              -- especially since in the export-list they might not even
              -- be next to each other.  But a proper implementation would
              -- really need to find the type of *all* exports as well as
              -- addressing all these issues.  This implementation works
              -- adequately.  Do you see a way to improve the situation?
              -- Please go ahead!  I got stuck trying to figure out how to
              -- get the 'PostTcType's that we want for all the bindings
              -- of an HsBind (you get 'LHsBinds' from 'GHC.typecheckedSource'
              -- for example).
              --
              -- But I might be missing something obvious.  What's important
              -- /here/ is that we behave reasonably when we run into one of
              -- those exported type-inferenced values.
              isLocalAndTypeInferenced <- liftGhcToErrMsgGhc $ do
                    let mdl = nameModule t
                    if modulePackageId mdl == thisPackage dflags then
                      isLoaded (moduleName mdl)
                    else return False

              if isLocalAndTypeInferenced then do
                -- I don't think there can be any subs in this case,
                -- currently?  But better not to rely on it.
                let subs = subordinatesWithNoDocs (unLoc hsdecl)
                return [ mkExportDecl t (hsdecl, noDocForDecl, subs) ]
              else
                -- We try to get the subs and docs
                -- from the installed interface of that package.
                case Map.lookup (nameModule t) instIfaceMap of
                  -- It's Nothing in the cases where I thought
                  -- Haddock has already warned the user: "Warning: The
                  -- documentation for the following packages are not
                  -- installed. No links will be generated to these packages:
                  -- ..."
                  -- But I guess it was Cabal creating that warning. Anyway,
                  -- this is more serious than links: it's exported decls where
                  -- we don't have the docs that they deserve!

                  -- We could use 'subordinates' to find the Names of the subs
                  -- (with no docs). Is that necessary? Yes it is, otherwise
                  -- e.g. classes will be shown without their exported subs.
                  Nothing -> do
                     liftErrMsg $ tell
                        ["Warning: Couldn't find .haddock for exported "
                        ++ exportInfoString]
                     let subs = subordinatesWithNoDocs (unLoc hsdecl)
                     return [ mkExportDecl t (hsdecl, noDocForDecl, subs) ]
                  Just iface -> do
                     let subs = case Map.lookup t (instSubMap iface) of
                             Nothing -> []
                             Just x -> x
                     return [ mkExportDecl t
                       ( hsdecl
                       , fromMaybe noDocForDecl $
                            Map.lookup t (instDocMap iface)
                       , map (\subt ->
                                ( subt ,
                                  fromMaybe noDocForDecl $
                                     Map.lookup subt (instDocMap iface)
                                )
                             ) subs
                       )]


    mkExportDecl :: Name -> DeclInfo -> ExportItem Name
    mkExportDecl n (decl, doc, subs) = decl'
      where
        decl' = ExportDecl (restrictTo sub_names (extractDecl n mdl decl)) doc subs' []
        mdl = nameModule n
        subs' = filter (isExported . fst) subs
        sub_names = map fst subs'


    isExported = (`elem` exportedNames)


    findDecl :: Name -> Maybe DeclInfo
    findDecl n
      | m == thisMod = Map.lookup n declMap
      | otherwise = case Map.lookup m modMap of
                      Just iface -> Map.lookup n (ifaceDeclMap iface)
                      Nothing -> Nothing
      where
        m = nameModule n


-- | Return all export items produced by an exported module. That is, we're
-- interested in the exports produced by \"module B\" in such a scenario:
--
-- > module A (module B) where
-- > import B (...) hiding (...)
--
-- There are three different cases to consider:
--
-- 1) B is hidden, in which case we return all its exports that are in scope in A.
-- 2) B is visible, but not all its exports are in scope in A, in which case we
--    only return those that are.
-- 3) B is visible and all its exports are in scope, in which case we return
--    a single 'ExportModule' item. 
moduleExports :: Module           -- ^ Module A
              -> ModuleName       -- ^ The real name of B, the exported module
              -> DynFlags         -- ^ The flag used when typechecking A
              -> GlobalRdrEnv     -- ^ The renaming environment used for A
              -> [Name]           -- ^ All the exports of A
              -> [DeclInfo]       -- ^ All the declarations in A
              -> IfaceMap         -- ^ Already created interfaces
              -> InstIfaceMap     -- ^ Interfaces in other packages
              -> ErrMsgGhc [ExportItem Name] -- ^ Resulting export items
moduleExports thisMod expMod dflags gre _exports decls ifaceMap instIfaceMap
  | m == thisMod = liftErrMsg $ fullContentsOfThisModule dflags gre decls
  | otherwise =
    case Map.lookup m ifaceMap of
      Just iface
        | OptHide `elem` ifaceOptions iface -> return (ifaceExportItems iface)
        | otherwise -> return [ ExportModule m ]

      Nothing -> -- we have to try to find it in the installed interfaces
                 -- (external packages)
        case Map.lookup expMod (Map.mapKeys moduleName instIfaceMap) of
          Just iface -> return [ ExportModule (instMod iface) ]
          Nothing -> do
            liftErrMsg $
              tell ["Warning: " ++ pretty thisMod ++ ": Could not find " ++
                    "documentation for exported module: " ++ pretty expMod]
            return []
  where
    m = mkModule packageId expMod
    packageId = modulePackageId thisMod


-- Note [1]:
------------
-- It is unnecessary to document a subordinate by itself at the top level if
-- any of its parents is also documented. Furthermore, if the subordinate is a
-- record field or a class method, documenting it under its parent
-- indicates its special status.
--
-- A user might expect that it should show up separately, so we issue a
-- warning. It's a fine opportunity to also tell the user she might want to
-- export the subordinate through the parent export item for clarity.
--
-- The code removes top-level subordinates also when the parent is exported
-- through a 'module' export. I think that is fine.
--
-- (For more information, see Trac #69)


fullContentsOfThisModule :: DynFlags -> GlobalRdrEnv -> [DeclInfo] -> ErrMsgM [ExportItem Name]
fullContentsOfThisModule dflags gre decls = liftM catMaybes $ mapM mkExportItem decls
  where
    mkExportItem (L _ (DocD (DocGroup lev docStr)), _, _) = do
        mbDoc <- lexParseRnHaddockComment dflags DocSectionComment gre docStr
        return $ fmap (ExportGroup lev "") mbDoc
    mkExportItem (L _ (DocD (DocCommentNamed _ docStr)), _, _) = do
        mbDoc <- lexParseRnHaddockComment dflags NormalHaddockComment gre docStr
        return $ fmap ExportDoc mbDoc
    mkExportItem (decl, doc, subs) = return $ Just $ ExportDecl decl doc subs []


-- | Sometimes the declaration we want to export is not the "main" declaration:
-- it might be an individual record selector or a class method.  In these
-- cases we have to extract the required declaration (and somehow cobble
-- together a type signature for it...)
extractDecl :: Name -> Module -> Decl -> Decl
extractDecl name mdl decl
  | name `elem` getMainDeclBinder (unLoc decl) = decl
  | otherwise  =
    case unLoc decl of
      TyClD d | isClassDecl d ->
        let matches = [ sig | sig <- tcdSigs d, name `elem` sigName sig,
                        isVanillaLSig sig ] -- TODO: document fixity
        in case matches of
          [s0] -> let (n, tyvar_names) = name_and_tyvars d
                      L pos sig = extractClassDecl n tyvar_names s0
                  in L pos (SigD sig)
          _ -> error "internal: extractDecl"
      TyClD d | isDataDecl d ->
        let (n, tyvar_names) = name_and_tyvars d
            L pos sig = extractRecSel name mdl n tyvar_names (tcdCons d)
        in L pos (SigD sig)
      _ -> error "internal: extractDecl"
  where
    name_and_tyvars d = (unLoc (tcdLName d), hsLTyVarLocNames (tcdTyVars d))


toTypeNoLoc :: Located Name -> LHsType Name
toTypeNoLoc = noLoc . HsTyVar . unLoc


extractClassDecl :: Name -> [Located Name] -> LSig Name -> LSig Name
extractClassDecl c tvs0 (L pos (TypeSig lname ltype)) = case ltype of
  L _ (HsForAllTy expl tvs (L _ preds) ty) ->
    L pos (TypeSig lname (noLoc (HsForAllTy expl tvs (lctxt preds) ty)))
  _ -> L pos (TypeSig lname (noLoc (mkImplicitHsForAllTy (lctxt []) ltype)))
  where
    lctxt = noLoc . ctxt
    ctxt preds = noLoc (HsClassP c (map toTypeNoLoc tvs0)) : preds
extractClassDecl _ _ _ = error "extractClassDecl: unexpected decl"


extractRecSel :: Name -> Module -> Name -> [Located Name] -> [LConDecl Name]
              -> LSig Name
extractRecSel _ _ _ _ [] = error "extractRecSel: selector not found"

extractRecSel nm mdl t tvs (L _ con : rest) =
  case con_details con of
    RecCon fields | (ConDeclField n ty _ : _) <- matching_fields fields ->
      L (getLoc n) (TypeSig [noLoc nm] (noLoc (HsFunTy data_ty (getBangType ty))))
    _ -> extractRecSel nm mdl t tvs rest
 where
  matching_fields flds = [ f | f@(ConDeclField n _ _) <- flds, unLoc n == nm ]
  data_ty = foldl (\x y -> noLoc (HsAppTy x y)) (noLoc (HsTyVar t)) (map toTypeNoLoc tvs)


-- Pruning
pruneExportItems :: [ExportItem Name] -> [ExportItem Name]
pruneExportItems items = filter hasDoc items
  where
    hasDoc (ExportDecl{expItemMbDoc = (d, _)}) = isJust d
    hasDoc _ = True


mkVisibleNames :: [ExportItem Name] -> [DocOption] -> [Name]
mkVisibleNames exports opts
  | OptHide `elem` opts = []
  | otherwise = concatMap exportName exports
  where
    exportName e@ExportDecl {} = getMainDeclBinder (unL $ expItemDecl e) ++ subs
      where subs = map fst (expItemSubDocs e)
    exportName ExportNoDecl {} = [] -- we don't count these as visible, since
                                    -- we don't want links to go to them.
    exportName _ = []


-- | Find a stand-alone documentation comment by its name
findNamedDoc :: String -> [HsDecl Name] -> ErrMsgM (Maybe HsDocString)
findNamedDoc name decls = search decls
  where
    search [] = do
      tell ["Cannot find documentation for: $" ++ name]
      return Nothing
    search ((DocD (DocCommentNamed name' doc)):rest)
      | name == name' = return (Just doc)
      | otherwise = search rest
    search (_other_decl : rest) = search rest