compiler/rename/RnNames.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 \section[RnNames]{Extracting imported and top-level names in scope}
   5
   6 \begin{code}
   7 module RnNames (
   8         rnImports, getLocalNonValBinders,
   9         rnExports, extendGlobalRdrEnvRn,
  10         gresFromAvails,
  11         reportUnusedNames, finishWarnings,
  12     ) where
  13
  14 #include "HsVersions.h"
  15
  16 import DynFlags
  17 import HsSyn
  18 import TcEnv            ( isBrackStage )
  19 import RnEnv
  20 import RnHsDoc          ( rnHsDoc )
  21 import IfaceEnv         ( ifaceExportNames )
  22 import LoadIface        ( loadSrcInterface )
  23 import TcRnMonad
  24
  25 import HeaderInfo       ( mkPrelImports )
  26 import PrelNames
  27 import Module
  28 import Name
  29 import NameEnv
  30 import NameSet
  31 import HscTypes
  32 import RdrName
  33 import Outputable
  34 import Maybes
  35 import SrcLoc
  36 import ErrUtils
  37 import Util
  38 import FastString
  39 import ListSetOps
  40 import Data.List        ( partition, (\\), delete )
  41 import qualified Data.Set as Set
  42 import System.IO
  43 import Control.Monad
  44 import Data.Map (Map)
  45 import qualified Data.Map as Map
  46 \end{code}
  47
  48
  49
  50 %************************************************************************
  51 %*                                                                      *
  52                 rnImports
  53 %*                                                                      *
  54 %************************************************************************
  55
  56 \begin{code}
  57 rnImports :: [LImportDecl RdrName]
  58            -> RnM ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage)
  59
  60 rnImports imports
  61          -- PROCESS IMPORT DECLS
  62          -- Do the non {- SOURCE -} ones first, so that we get a helpful
  63          -- warning for {- SOURCE -} ones that are unnecessary
  64     = do this_mod <- getModule
  65          implicit_prelude <- xoptM Opt_ImplicitPrelude
  66          let prel_imports       = mkPrelImports (moduleName this_mod) implicit_prelude imports
  67              (source, ordinary) = partition is_source_import imports
  68              is_source_import (L _ (ImportDecl _ _ is_boot _ _ _)) = is_boot
  69
  70          ifDOptM Opt_WarnImplicitPrelude (
  71             when (notNull prel_imports) $ addWarn (implicitPreludeWarn)
  72           )
  73
  74          stuff1 <- mapM (rnImportDecl this_mod True)  prel_imports
  75          stuff2 <- mapM (rnImportDecl this_mod False) ordinary
  76          stuff3 <- mapM (rnImportDecl this_mod False) source
  77          let (decls, rdr_env, imp_avails, hpc_usage) = combine (stuff1 ++ stuff2 ++ stuff3)
  78          return (decls, rdr_env, imp_avails, hpc_usage)
  79
  80     where
  81    combine :: [(LImportDecl Name,  GlobalRdrEnv, ImportAvails,AnyHpcUsage)]
  82            -> ([LImportDecl Name], GlobalRdrEnv, ImportAvails,AnyHpcUsage)
  83    combine = foldr plus ([], emptyGlobalRdrEnv, emptyImportAvails,False)
  84         where plus (decl,  gbl_env1, imp_avails1,hpc_usage1)
  85                    (decls, gbl_env2, imp_avails2,hpc_usage2)
  86                 = (decl:decls,
  87                    gbl_env1 `plusGlobalRdrEnv` gbl_env2,
  88                    imp_avails1 `plusImportAvails` imp_avails2,
  89                    hpc_usage1 || hpc_usage2)
  90
  91 rnImportDecl  :: Module -> Bool
  92               -> LImportDecl RdrName
  93               -> RnM (LImportDecl Name, GlobalRdrEnv, ImportAvails,AnyHpcUsage)
  94
  95 rnImportDecl this_mod implicit_prelude
  96              (L loc (ImportDecl { ideclName = loc_imp_mod_name, ideclPkgQual = mb_pkg
  97                                 , ideclSource = want_boot, ideclQualified = qual_only
  98                                 , ideclAs = as_mod, ideclHiding = imp_details }))
  99   = setSrcSpan loc $ do
 100
 101     when (isJust mb_pkg) $ do
 102         pkg_imports <- xoptM Opt_PackageImports
 103         when (not pkg_imports) $ addErr packageImportErr
 104
 105         -- If there's an error in loadInterface, (e.g. interface
 106         -- file not found) we get lots of spurious errors from 'filterImports'
 107     let
 108         imp_mod_name = unLoc loc_imp_mod_name
 109         doc = ppr imp_mod_name <+> ptext (sLit "is directly imported")
 110
 111         -- Check for a missing import list
 112         -- (Opt_WarnMissingImportList also checks for T(..) items
 113         --  but that is done in checkDodgyImport below)
 114     case imp_details of
 115         Just (False, _)       -> return ()
 116         _  | implicit_prelude -> return ()
 117            | otherwise        -> ifDOptM Opt_WarnMissingImportList $
 118                                  addWarn (missingImportListWarn imp_mod_name)
 119
 120     iface <- loadSrcInterface doc imp_mod_name want_boot mb_pkg
 121
 122         -- Compiler sanity check: if the import didn't say
 123         -- {-# SOURCE #-} we should not get a hi-boot file
 124     WARN( not want_boot && mi_boot iface, ppr imp_mod_name ) (do
 125
 126         -- Issue a user warning for a redundant {- SOURCE -} import
 127         -- NB that we arrange to read all the ordinary imports before
 128         -- any of the {- SOURCE -} imports.
 129         --
 130         -- in --make and GHCi, the compilation manager checks for this,
 131         -- and indeed we shouldn't do it here because the existence of
 132         -- the non-boot module depends on the compilation order, which
 133         -- is not deterministic.  The hs-boot test can show this up.
 134     dflags <- getDOpts
 135     warnIf (want_boot && not (mi_boot iface) && isOneShot (ghcMode dflags))
 136            (warnRedundantSourceImport imp_mod_name)
 137
 138     let
 139         imp_mod    = mi_module iface
 140         warns      = mi_warns iface
 141         orph_iface = mi_orphan iface
 142         has_finsts = mi_finsts iface
 143         deps       = mi_deps iface
 144
 145         filtered_exports = filter not_this_mod (mi_exports iface)
 146         not_this_mod (mod,_) = mod /= this_mod
 147         -- If the module exports anything defined in this module, just
 148         -- ignore it.  Reason: otherwise it looks as if there are two
 149         -- local definition sites for the thing, and an error gets
 150         -- reported.  Easiest thing is just to filter them out up
 151         -- front. This situation only arises if a module imports
 152         -- itself, or another module that imported it.  (Necessarily,
 153         -- this invoves a loop.)
 154         --
 155         -- Tiresome consequence: if you say
 156         --      module A where
 157         --         import B( AType )
 158         --         type AType = ...
 159         --
 160         --      module B( AType ) where
 161         --         import {-# SOURCE #-} A( AType )
 162         --
 163         -- then you'll get a 'B does not export AType' message.  Oh well.
 164
 165         qual_mod_name = case as_mod of
 166                           Nothing           -> imp_mod_name
 167                           Just another_name -> another_name
 168         imp_spec  = ImpDeclSpec { is_mod = imp_mod_name, is_qual = qual_only,
 169                                   is_dloc = loc, is_as = qual_mod_name }
 170     -- in
 171
 172         -- Get the total exports from this module
 173     total_avails <- ifaceExportNames filtered_exports
 174
 175         -- filter the imports according to the import declaration
 176     (new_imp_details, gbl_env) <-
 177         filterImports iface imp_spec imp_details total_avails
 178
 179     dflags <- getDOpts
 180
 181     let
 182         -- Compute new transitive dependencies
 183
 184         orphans | orph_iface = ASSERT( not (imp_mod `elem` dep_orphs deps) )
 185                                imp_mod : dep_orphs deps
 186                 | otherwise  = dep_orphs deps
 187
 188         finsts | has_finsts = ASSERT( not (imp_mod `elem` dep_finsts deps) )
 189                               imp_mod : dep_finsts deps
 190                 | otherwise = dep_finsts deps
 191
 192         pkg = modulePackageId (mi_module iface)
 193
 194         (dependent_mods, dependent_pkgs)
 195            | pkg == thisPackage dflags =
 196                 -- Imported module is from the home package
 197                 -- Take its dependent modules and add imp_mod itself
 198                 -- Take its dependent packages unchanged
 199                 --
 200                 -- NB: (dep_mods deps) might include a hi-boot file
 201                 -- for the module being compiled, CM. Do *not* filter
 202                 -- this out (as we used to), because when we've
 203                 -- finished dealing with the direct imports we want to
 204                 -- know if any of them depended on CM.hi-boot, in
 205                 -- which case we should do the hi-boot consistency
 206                 -- check.  See LoadIface.loadHiBootInterface
 207                   ((imp_mod_name, want_boot) : dep_mods deps, dep_pkgs deps)
 208
 209            | otherwise =
 210                 -- Imported module is from another package
 211                 -- Dump the dependent modules
 212                 -- Add the package imp_mod comes from to the dependent packages
 213                  ASSERT2( not (pkg `elem` dep_pkgs deps), ppr pkg <+> ppr (dep_pkgs deps) )
 214                  ([], pkg : dep_pkgs deps)
 215
 216         -- True <=> import M ()
 217         import_all = case imp_details of
 218                         Just (is_hiding, ls) -> not is_hiding && null ls
 219                         _                    -> False
 220
 221         imports   = ImportAvails {
 222                         imp_mods     = unitModuleEnv imp_mod [(qual_mod_name, import_all, loc)],
 223                         imp_orphs    = orphans,
 224                         imp_finsts   = finsts,
 225                         imp_dep_mods = mkModDeps dependent_mods,
 226                         imp_dep_pkgs = dependent_pkgs
 227                    }
 228
 229         -- Complain if we import a deprecated module
 230     ifDOptM Opt_WarnWarningsDeprecations        (
 231        case warns of
 232           WarnAll txt -> addWarn (moduleWarn imp_mod_name txt)
 233           _           -> return ()
 234      )
 235
 236     let new_imp_decl = L loc (ImportDecl loc_imp_mod_name mb_pkg want_boot
 237                                          qual_only as_mod new_imp_details)
 238
 239     return (new_imp_decl, gbl_env, imports, mi_hpc iface)
 240     )
 241
 242 warnRedundantSourceImport :: ModuleName -> SDoc
 243 warnRedundantSourceImport mod_name
 244   = ptext (sLit "Unnecessary {-# SOURCE #-} in the import of module")
 245           <+> quotes (ppr mod_name)
 246 \end{code}
 247
 248
 249 %************************************************************************
 250 %*                                                                      *
 251                 importsFromLocalDecls
 252 %*                                                                      *
 253 %************************************************************************
 254
 255 From the top-level declarations of this module produce
 256         * the lexical environment
 257         * the ImportAvails
 258 created by its bindings.
 259
 260 Note [Top-level Names in Template Haskell decl quotes]
 261 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 262 Consider a Template Haskell declaration quotation like this:
 263       module M where
 264         f x = h [d| f = 3 |]
 265 When renaming the declarations inside [d| ...|], we treat the
 266 top level binders specially in two ways
 267
 268 1.  We give them an Internal name, not (as usual) an External one.
 269     Otherwise the NameCache gets confused by a second allocation of
 270     M.f.  (We used to invent a fake module ThFake to avoid this, but
 271     that had other problems, notably in getting the correct answer for
 272     nameIsLocalOrFrom in lookupFixity. So we now leave tcg_module
 273     unaffected.)
 274
 275 2.  We make them *shadow* the outer bindings. If we don't do that,
 276     we'll get a complaint when extending the GlobalRdrEnv, saying that
 277     there are two bindings for 'f'.  There are several tricky points:
 278
 279     * This shadowing applies even if the binding for 'f' is in a
 280       where-clause, and hence is in the *local* RdrEnv not the *global*
 281       RdrEnv.
 282
 283     * The *qualified* name M.f from the enclosing module must certainly
 284       still be available.  So we don't nuke it entirely; we just make
 285       it seem like qualified import.
 286
 287     * We only shadow *External* names (which come from the main module)
 288       Do not shadow *Inernal* names because in the bracket
 289           [d| class C a where f :: a
 290               f = 4 |]
 291       rnSrcDecls will first call extendGlobalRdrEnvRn with C[f] from the
 292       class decl, and *separately* extend the envt with the value binding.
 293
 294 3. We find out whether we are inside a [d| ... |] by testing the TH
 295    stage. This is a slight hack, because the stage field was really
 296    meant for the type checker, and here we are not interested in the
 297    fields of Brack, hence the error thunks in thRnBrack.
 298
 299 \begin{code}
 300 extendGlobalRdrEnvRn :: [AvailInfo]
 301                      -> MiniFixityEnv
 302                      -> RnM (TcGblEnv, TcLclEnv)
 303   -- Updates both the GlobalRdrEnv and the FixityEnv
 304   -- We return a new TcLclEnv only because we might have to
 305   -- delete some bindings from it;
 306   -- see Note [Top-level Names in Template Haskell decl quotes]
 307
 308 extendGlobalRdrEnvRn avails new_fixities
 309   = do  { (gbl_env, lcl_env) <- getEnvs
 310         ; stage <- getStage
 311         ; let rdr_env = tcg_rdr_env gbl_env
 312               fix_env = tcg_fix_env gbl_env
 313
 314                 -- Delete new_occs from global and local envs
 315                 -- If we are in a TemplateHaskell decl bracket,
 316                 --    we are going to shadow them
 317                 -- See Note [Top-level Names in Template Haskell decl quotes]
 318               shadowP  = isBrackStage stage
 319               new_occs = map (nameOccName . gre_name) gres
 320               rdr_env1 = transformGREs qual_gre new_occs rdr_env
 321               lcl_env1 = lcl_env { tcl_rdr = delListFromOccEnv (tcl_rdr lcl_env) new_occs }
 322               (rdr_env2, lcl_env2) | shadowP   = (rdr_env1, lcl_env1)
 323                                    | otherwise = (rdr_env,  lcl_env)
 324
 325               rdr_env3 = foldl extendGlobalRdrEnv rdr_env2 gres
 326               fix_env' = foldl extend_fix_env     fix_env  gres
 327               (rdr_env', dups) = findLocalDupsRdrEnv rdr_env3 new_occs
 328
 329               gbl_env' = gbl_env { tcg_rdr_env = rdr_env', tcg_fix_env = fix_env' }
 330
 331         ; mapM_ addDupDeclErr dups
 332
 333         ; traceRn (text "extendGlobalRdrEnvRn" <+> (ppr new_fixities $$ ppr fix_env $$ ppr fix_env'))
 334         ; return (gbl_env', lcl_env2) }
 335   where
 336     gres = gresFromAvails LocalDef avails
 337
 338         --  If there is a fixity decl for the gre, add it to the fixity env
 339     extend_fix_env fix_env gre
 340       | Just (L _ fi) <- lookupFsEnv new_fixities (occNameFS occ)
 341       = extendNameEnv fix_env name (FixItem occ fi)
 342       | otherwise
 343       = fix_env
 344       where
 345         name = gre_name gre
 346         occ  = nameOccName name
 347
 348     qual_gre :: GlobalRdrElt -> GlobalRdrElt
 349     -- Transform top-level GREs from the module being compiled
 350     -- so that they are out of the way of new definitions in a Template
 351     -- Haskell bracket
 352     -- See Note [Top-level Names in Template Haskell decl quotes]
 353     -- Seems like 5 times as much work as it deserves!
 354     --
 355     -- For a LocalDef we make a (fake) qualified imported GRE for a
 356     -- local GRE so that the original *qualified* name is still in scope
 357     -- but the *unqualified* one no longer is.  What a hack!
 358
 359     qual_gre gre@(GRE { gre_prov = LocalDef, gre_name = name })
 360         | isExternalName name = gre { gre_prov = Imported [imp_spec] }
 361         | otherwise           = gre
 362            -- Do not shadow Internal (ie Template Haskell) Names
 363            -- See Note [Top-level Names in Template Haskell decl quotes]
 364         where
 365           mod = ASSERT2( isExternalName name, ppr name) moduleName (nameModule name)
 366           imp_spec = ImpSpec { is_item = ImpAll, is_decl = decl_spec }
 367           decl_spec = ImpDeclSpec { is_mod = mod, is_as = mod,
 368                                     is_qual = True,     -- Qualified only!
 369                                     is_dloc = srcLocSpan (nameSrcLoc name) }
 370
 371     qual_gre gre@(GRE { gre_prov = Imported specs })
 372         = gre { gre_prov = Imported (map qual_spec specs) }
 373
 374     qual_spec spec@(ImpSpec { is_decl = decl_spec })
 375         = spec { is_decl = decl_spec { is_qual = True } }
 376 \end{code}
 377
 378 @getLocalDeclBinders@ returns the names for an @HsDecl@.  It's
 379 used for source code.
 380
 381         *** See "THE NAMING STORY" in HsDecls ****
 382
 383 Instances of type families
 384 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 385 Family instances contain data constructors that we need to collect and we also
 386 need to descend into the type instances of associated families in class
 387 instances. The type constructor of a family instance is a usage occurence.
 388 Hence, we don't return it as a subname in 'AvailInfo'; otherwise, we would get
 389 a duplicate declaration error.
 390
 391 Note [Looking up family names in family instances]
 392 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 393 Consider
 394
 395   module M where
 396     type family T a :: *
 397     type instance M.T Int = Bool
 398
 399 We might think that we can simply use 'lookupOccRn' when processing the type
 400 instance to look up 'M.T'.  Alas, we can't!  The type family declaration is in
 401 the *same* HsGroup as the type instance declaration.  Hence, as we are
 402 currently collecting the binders declared in that HsGroup, these binders will
 403 not have been added to the global environment yet.
 404
 405 In the case of type classes, this problem does not arise, as a class instance
 406 does not define any binders of it's own.  So, we simply don't attempt to look
 407 up the class names of class instances in 'get_local_binders' below.
 408
 409 If we don't look up class instances, can't we get away without looking up type
 410 instances, too?  No, we can't.  Data type instances define data constructors
 411 and we need to
 412
 413   (1) collect those in 'get_local_binders' and
 414   (2) we need to get their parent name in 'get_local_binders', too, to
 415       produce an appropriate 'AvailTC'.
 416
 417 This parent name is exactly the family name of the type instance that is so
 418 difficult to look up.
 419
 420 We solve this problem as follows:
 421
 422   (a) We process all type declarations other than type instances first.
 423   (b) Then, we compute a 'GlobalRdrEnv' from the result of the first step.
 424   (c) Finally, we process all type instances (both those on the toplevel and
 425       those nested in class instances) and check for the family names in the
 426       'GlobalRdrEnv' produced in the previous step before using 'lookupOccRn'.
 427
 428 \begin{code}
 429 getLocalNonValBinders :: HsGroup RdrName -> RnM [AvailInfo]
 430 -- Get all the top-level binders bound the group *except*
 431 -- for value bindings, which are treated separately
 432 -- Specificaly we return AvailInfo for
 433 --      type decls (incl constructors and record selectors)
 434 --      class decls (including class ops)
 435 --      associated types
 436 --      foreign imports
 437 --      (in hs-boot files) value signatures
 438
 439 getLocalNonValBinders group
 440   = do  { gbl_env <- getGblEnv
 441         ; get_local_binders gbl_env group }
 442
 443 get_local_binders :: TcGblEnv -> HsGroup RdrName -> RnM [GenAvailInfo Name]
 444 get_local_binders gbl_env (HsGroup {hs_valds  = ValBindsIn _ val_sigs,
 445                                     hs_tyclds = tycl_decls,
 446                                     hs_instds = inst_decls,
 447                                     hs_fords  = foreign_decls })
 448   = do  {   -- separate out the family instance declarations
 449           let (tyinst_decls1, tycl_decls_noinsts)
 450                            = partition (isFamInstDecl . unLoc) tycl_decls
 451               tyinst_decls = tyinst_decls1 ++ instDeclATs inst_decls
 452
 453             -- process all type/class decls except family instances
 454         ; tc_names  <- mapM new_tc tycl_decls_noinsts
 455
 456             -- create a temporary rdr env of the type binders
 457         ; let tc_gres     = gresFromAvails LocalDef tc_names
 458               tc_name_env = foldl extendGlobalRdrEnv emptyGlobalRdrEnv tc_gres
 459
 460             -- process all family instances
 461         ; ti_names  <- mapM (new_ti tc_name_env) tyinst_decls
 462
 463             -- finish off with value binder in case of a hs-boot file
 464         ; val_names <- mapM new_simple val_bndrs
 465         ; return (val_names ++ tc_names ++ ti_names) }
 466   where
 467     is_hs_boot = isHsBoot (tcg_src gbl_env) ;
 468
 469     for_hs_bndrs :: [Located RdrName]
 470     for_hs_bndrs = [nm | L _ (ForeignImport nm _ _) <- foreign_decls]
 471
 472     -- In a hs-boot file, the value binders come from the
 473     --  *signatures*, and there should be no foreign binders
 474     val_bndrs :: [Located RdrName]
 475     val_bndrs | is_hs_boot = [nm | L _ (TypeSig nm _) <- val_sigs]
 476               | otherwise  = for_hs_bndrs
 477
 478     new_simple :: Located RdrName -> RnM (GenAvailInfo Name)
 479     new_simple rdr_name = do
 480         nm <- newTopSrcBinder rdr_name
 481         return (Avail nm)
 482
 483     new_tc tc_decl              -- NOT for type/data instances
 484         = do { main_name <- newTopSrcBinder main_rdr
 485              ; sub_names <- mapM newTopSrcBinder sub_rdrs
 486              ; return (AvailTC main_name (main_name : sub_names)) }
 487       where
 488         (main_rdr : sub_rdrs) = hsTyClDeclBinders tc_decl
 489
 490     new_ti tc_name_env ti_decl  -- ONLY for type/data instances
 491         = do { main_name <- lookupFamInstDeclBndr tc_name_env main_rdr
 492              ; sub_names <- mapM newTopSrcBinder sub_rdrs
 493              ; return (AvailTC main_name sub_names) }
 494                         -- main_name is not bound here!
 495       where
 496         (main_rdr : sub_rdrs) = hsTyClDeclBinders ti_decl
 497
 498 get_local_binders _ g = pprPanic "get_local_binders" (ppr g)
 499 \end{code}
 500
 501
 502 %************************************************************************
 503 %*                                                                      *
 504 \subsection{Filtering imports}
 505 %*                                                                      *
 506 %************************************************************************
 507
 508 @filterImports@ takes the @ExportEnv@ telling what the imported module makes
 509 available, and filters it through the import spec (if any).
 510
 511 \begin{code}
 512 filterImports :: ModIface
 513               -> ImpDeclSpec                    -- The span for the entire import decl
 514               -> Maybe (Bool, [LIE RdrName])    -- Import spec; True => hiding
 515               -> [AvailInfo]                    -- What's available
 516               -> RnM (Maybe (Bool, [LIE Name]), -- Import spec w/ Names
 517                       GlobalRdrEnv)             -- Same again, but in GRE form
 518 filterImports _ decl_spec Nothing all_avails
 519   = return (Nothing, mkGlobalRdrEnv (gresFromAvails prov all_avails))
 520   where
 521     prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
 522
 523
 524 filterImports iface decl_spec (Just (want_hiding, import_items)) all_avails
 525   = do   -- check for errors, convert RdrNames to Names
 526         opt_typeFamilies <- xoptM Opt_TypeFamilies
 527         items1 <- mapM (lookup_lie opt_typeFamilies) import_items
 528
 529         let items2 :: [(LIE Name, AvailInfo)]
 530             items2 = concat items1
 531                 -- NB the AvailInfo may have duplicates, and several items
 532                 --    for the same parent; e.g N(x) and N(y)
 533
 534             names  = availsToNameSet (map snd items2)
 535             keep n = not (n `elemNameSet` names)
 536             pruned_avails = filterAvails keep all_avails
 537             hiding_prov = Imported [ImpSpec { is_decl = decl_spec, is_item = ImpAll }]
 538
 539             gres | want_hiding = gresFromAvails hiding_prov pruned_avails
 540                  | otherwise   = concatMap (gresFromIE decl_spec) items2
 541
 542         return (Just (want_hiding, map fst items2), mkGlobalRdrEnv gres)
 543   where
 544         -- This environment is how we map names mentioned in the import
 545         -- list to the actual Name they correspond to, and the name family
 546         -- that the Name belongs to (the AvailInfo).  The situation is
 547         -- complicated by associated families, which introduce a three-level
 548         -- hierachy, where class = grand parent, assoc family = parent, and
 549         -- data constructors = children.  The occ_env entries for associated
 550         -- families needs to capture all this information; hence, we have the
 551         -- third component of the environment that gives the class name (=
 552         -- grand parent) in case of associated families.
 553         --
 554         -- This env will have entries for data constructors too,
 555         -- they won't make any difference because naked entities like T
 556         -- in an import list map to TcOccs, not VarOccs.
 557     occ_env :: OccEnv (Name,        -- the name
 558                        AvailInfo,   -- the export item providing the name
 559                        Maybe Name)  -- the parent of associated types
 560     occ_env = mkOccEnv_C combine [ (nameOccName n, (n, a, Nothing))
 561                                  | a <- all_avails, n <- availNames a]
 562       where
 563         -- we know that (1) there are at most entries for one name, (2) their
 564         -- first component is identical, (3) they are for tys/cls, and (4) one
 565         -- entry has the name in its parent position (the other doesn't)
 566         combine (name, AvailTC p1 subs1, Nothing)
 567                 (_   , AvailTC p2 subs2, Nothing)
 568           = let
 569               (parent, subs) = if p1 == name then (p2, subs1) else (p1, subs2)
 570             in
 571             (name, AvailTC name subs, Just parent)
 572         combine x y = pprPanic "filterImports/combine" (ppr x $$ ppr y)
 573
 574     lookup_lie :: Bool -> LIE RdrName -> TcRn [(LIE Name, AvailInfo)]
 575     lookup_lie opt_typeFamilies (L loc ieRdr)
 576         = do
 577              stuff <- setSrcSpan loc $
 578                       case lookup_ie opt_typeFamilies ieRdr of
 579                             Failed err  -> addErr err >> return []
 580                             Succeeded a -> return a
 581              checkDodgyImport stuff
 582              return [ (L loc ie, avail) | (ie,avail) <- stuff ]
 583         where
 584                 -- Warn when importing T(..) if T was exported abstractly
 585             checkDodgyImport stuff
 586                 | IEThingAll n <- ieRdr, (_, AvailTC _ [_]):_ <- stuff
 587                 = ifDOptM Opt_WarnDodgyImports (addWarn (dodgyImportWarn n))
 588                 -- NB. use the RdrName for reporting the warning
 589                 | IEThingAll {} <- ieRdr
 590                 = ifDOptM Opt_WarnMissingImportList $
 591                   addWarn (missingImportListItem ieRdr)
 592             checkDodgyImport _
 593                 = return ()
 594
 595         -- For each import item, we convert its RdrNames to Names,
 596         -- and at the same time construct an AvailInfo corresponding
 597         -- to what is actually imported by this item.
 598         -- Returns Nothing on error.
 599         -- We return a list here, because in the case of an import
 600         -- item like C, if we are hiding, then C refers to *both* a
 601         -- type/class and a data constructor.  Moreover, when we import
 602         -- data constructors of an associated family, we need separate
 603         -- AvailInfos for the data constructors and the family (as they have
 604         -- different parents).  See the discussion at occ_env.
 605     lookup_ie :: Bool -> IE RdrName -> MaybeErr Message [(IE Name,AvailInfo)]
 606     lookup_ie opt_typeFamilies ie
 607       = let bad_ie :: MaybeErr Message a
 608             bad_ie = Failed (badImportItemErr iface decl_spec ie)
 609
 610             lookup_name rdr
 611               | isQual rdr = Failed (qualImportItemErr rdr)
 612               | Just nm <- lookupOccEnv occ_env (rdrNameOcc rdr) = return nm
 613               | otherwise                                        = bad_ie
 614         in
 615         case ie of
 616          IEVar n -> do
 617              (name, avail, _) <- lookup_name n
 618              return [(IEVar name, trimAvail avail name)]
 619
 620          IEThingAll tc -> do
 621              (name, avail@(AvailTC name2 subs), mb_parent) <- lookup_name tc
 622              case mb_parent of
 623                -- non-associated ty/cls
 624                Nothing     -> return [(IEThingAll name, avail)]
 625                -- associated ty
 626                Just parent -> return [(IEThingAll name,
 627                                        AvailTC name2 (subs \\ [name])),
 628                                       (IEThingAll name, AvailTC parent [name])]
 629
 630          IEThingAbs tc
 631              | want_hiding   -- hiding ( C )
 632                         -- Here the 'C' can be a data constructor
 633                         --  *or* a type/class, or even both
 634              -> let tc_name = lookup_name tc
 635                     dc_name = lookup_name (setRdrNameSpace tc srcDataName)
 636                 in
 637                 case catMaybeErr [ tc_name, dc_name ] of
 638                   []    -> bad_ie
 639                   names -> return [mkIEThingAbs name | name <- names]
 640              | otherwise
 641              -> do nameAvail <- lookup_name tc
 642                    return [mkIEThingAbs nameAvail]
 643
 644          IEThingWith tc ns -> do
 645             (name, AvailTC _ subnames, mb_parent) <- lookup_name tc
 646             let
 647               env         = mkOccEnv [(nameOccName s, s) | s <- subnames]
 648               mb_children = map (lookupOccEnv env . rdrNameOcc) ns
 649             children <- if any isNothing mb_children
 650                         then bad_ie
 651                         else return (catMaybes mb_children)
 652               -- check for proper import of type families
 653             when (not opt_typeFamilies && any isTyConName children) $
 654               Failed (typeItemErr (head . filter isTyConName $ children)
 655                                   (text "in import list"))
 656             case mb_parent of
 657                -- non-associated ty/cls
 658               Nothing     -> return [(IEThingWith name children,
 659                                       AvailTC name (name:children))]
 660                -- associated ty
 661               Just parent -> return [(IEThingWith name children,
 662                                       AvailTC name children),
 663                                      (IEThingWith name children,
 664                                       AvailTC parent [name])]
 665
 666          _other -> Failed illegalImportItemErr
 667          -- could be IEModuleContents, IEGroup, IEDoc, IEDocNamed
 668          -- all errors.
 669
 670       where
 671         mkIEThingAbs (n, av, Nothing    ) = (IEThingAbs n, trimAvail av n)
 672         mkIEThingAbs (n, _,  Just parent) = (IEThingAbs n, AvailTC parent [n])
 673
 674
 675 catMaybeErr :: [MaybeErr err a] -> [a]
 676 catMaybeErr ms =  [ a | Succeeded a <- ms ]
 677 \end{code}
 678
 679 %************************************************************************
 680 %*                                                                      *
 681         Import/Export Utils
 682 %*                                                                      *
 683 %************************************************************************
 684
 685 \begin{code}
 686 -- | make a 'GlobalRdrEnv' where all the elements point to the same
 687 -- import declaration (useful for "hiding" imports, or imports with
 688 -- no details).
 689 gresFromAvails :: Provenance -> [AvailInfo] -> [GlobalRdrElt]
 690 gresFromAvails prov avails
 691   = concatMap (gresFromAvail (const prov)) avails
 692
 693 gresFromAvail :: (Name -> Provenance) -> AvailInfo -> [GlobalRdrElt]
 694 gresFromAvail prov_fn avail
 695   = [ GRE {gre_name = n,
 696            gre_par = availParent n avail,
 697            gre_prov = prov_fn n}
 698     | n <- availNames avail ]
 699
 700 greAvail :: GlobalRdrElt -> AvailInfo
 701 greAvail gre = mkUnitAvail (gre_name gre) (gre_par gre)
 702
 703 mkUnitAvail :: Name -> Parent -> AvailInfo
 704 mkUnitAvail me (ParentIs p)              = AvailTC p  [me]
 705 mkUnitAvail me NoParent | isTyConName me = AvailTC me [me]
 706                         | otherwise      = Avail me
 707
 708 plusAvail :: GenAvailInfo Name -> GenAvailInfo Name -> GenAvailInfo Name
 709 plusAvail (Avail n1)      (Avail _)        = Avail n1
 710 plusAvail (AvailTC _ ns1) (AvailTC n2 ns2) = AvailTC n2 (ns1 `unionLists` ns2)
 711 plusAvail a1 a2 = pprPanic "RnEnv.plusAvail" (hsep [ppr a1,ppr a2])
 712
 713 availParent :: Name -> AvailInfo -> Parent
 714 availParent _ (Avail _)                 = NoParent
 715 availParent n (AvailTC m _) | n == m    = NoParent
 716                             | otherwise = ParentIs m
 717
 718 trimAvail :: AvailInfo -> Name -> AvailInfo
 719 trimAvail (Avail n)      _ = Avail n
 720 trimAvail (AvailTC n ns) m = ASSERT( m `elem` ns) AvailTC n [m]
 721
 722 -- | filters 'AvailInfo's by the given predicate
 723 filterAvails  :: (Name -> Bool) -> [AvailInfo] -> [AvailInfo]
 724 filterAvails keep avails = foldr (filterAvail keep) [] avails
 725
 726 -- | filters an 'AvailInfo' by the given predicate
 727 filterAvail :: (Name -> Bool) -> AvailInfo -> [AvailInfo] -> [AvailInfo]
 728 filterAvail keep ie rest =
 729   case ie of
 730     Avail n | keep n    -> ie : rest
 731             | otherwise -> rest
 732     AvailTC tc ns ->
 733         let left = filter keep ns in
 734         if null left then rest else AvailTC tc left : rest
 735
 736 -- | Given an import\/export spec, construct the appropriate 'GlobalRdrElt's.
 737 gresFromIE :: ImpDeclSpec -> (LIE Name, AvailInfo) -> [GlobalRdrElt]
 738 gresFromIE decl_spec (L loc ie, avail)
 739   = gresFromAvail prov_fn avail
 740   where
 741     is_explicit = case ie of
 742                     IEThingAll name -> \n -> n == name
 743                     _               -> \_ -> True
 744     prov_fn name = Imported [imp_spec]
 745         where
 746           imp_spec  = ImpSpec { is_decl = decl_spec, is_item = item_spec }
 747           item_spec = ImpSome { is_explicit = is_explicit name, is_iloc = loc }
 748
 749 mkChildEnv :: [GlobalRdrElt] -> NameEnv [Name]
 750 mkChildEnv gres = foldr add emptyNameEnv gres
 751     where
 752         add (GRE { gre_name = n, gre_par = ParentIs p }) env = extendNameEnv_Acc (:) singleton env p n
 753         add _                                            env = env
 754
 755 findChildren :: NameEnv [Name] -> Name -> [Name]
 756 findChildren env n = lookupNameEnv env n `orElse` []
 757 \end{code}
 758
 759 ---------------------------------------
 760         AvailEnv and friends
 761
 762 All this AvailEnv stuff is hardly used; only in a very small
 763 part of RnNames.  Todo: remove?
 764 ---------------------------------------
 765
 766 \begin{code}
 767 type AvailEnv = NameEnv AvailInfo       -- Maps a Name to the AvailInfo that contains it
 768
 769 emptyAvailEnv :: AvailEnv
 770 emptyAvailEnv = emptyNameEnv
 771
 772 {- Dead code
 773 unitAvailEnv :: AvailInfo -> AvailEnv
 774 unitAvailEnv a = unitNameEnv (availName a) a
 775
 776 plusAvailEnv :: AvailEnv -> AvailEnv -> AvailEnv
 777 plusAvailEnv = plusNameEnv_C plusAvail
 778
 779 availEnvElts :: AvailEnv -> [AvailInfo]
 780 availEnvElts = nameEnvElts
 781 -}
 782
 783 addAvail :: AvailEnv -> AvailInfo -> AvailEnv
 784 addAvail avails avail = extendNameEnv_C plusAvail avails (availName avail) avail
 785
 786 mkAvailEnv :: [AvailInfo] -> AvailEnv
 787         -- 'avails' may have several items with the same availName
 788         -- E.g  import Ix( Ix(..), index )
 789         -- will give Ix(Ix,index,range) and Ix(index)
 790         -- We want to combine these; addAvail does that
 791 mkAvailEnv avails = foldl addAvail emptyAvailEnv avails
 792
 793 -- After combining the avails, we need to ensure that the parent name is the
 794 -- first entry in the list of subnames, if it is included at all.  (Subsequent
 795 -- functions rely on that.)
 796 normaliseAvail :: AvailInfo -> AvailInfo
 797 normaliseAvail avail@(Avail _)     = avail
 798 normaliseAvail (AvailTC name subs) = AvailTC name subs'
 799   where
 800     subs' = if name `elem` subs then name : (delete name subs) else subs
 801
 802 -- | combines 'AvailInfo's from the same family
 803 nubAvails :: [AvailInfo] -> [AvailInfo]
 804 nubAvails avails = map normaliseAvail . nameEnvElts . mkAvailEnv $ avails
 805 \end{code}
 806
 807
 808 %************************************************************************
 809 %*                                                                      *
 810 \subsection{Export list processing}
 811 %*                                                                      *
 812 %************************************************************************
 813
 814 Processing the export list.
 815
 816 You might think that we should record things that appear in the export
 817 list as ``occurrences'' (using @addOccurrenceName@), but you'd be
 818 wrong.  We do check (here) that they are in scope, but there is no
 819 need to slurp in their actual declaration (which is what
 820 @addOccurrenceName@ forces).
 821
 822 Indeed, doing so would big trouble when compiling @PrelBase@, because
 823 it re-exports @GHC@, which includes @takeMVar#@, whose type includes
 824 @ConcBase.StateAndSynchVar#@, and so on...
 825
 826 \begin{code}
 827 type ExportAccum        -- The type of the accumulating parameter of
 828                         -- the main worker function in rnExports
 829      = ([LIE Name],             -- Export items with Names
 830         ExportOccMap,           -- Tracks exported occurrence names
 831         [AvailInfo])            -- The accumulated exported stuff
 832                                 --   Not nub'd!
 833
 834 emptyExportAccum :: ExportAccum
 835 emptyExportAccum = ([], emptyOccEnv, [])
 836
 837 type ExportOccMap = OccEnv (Name, IE RdrName)
 838         -- Tracks what a particular exported OccName
 839         --   in an export list refers to, and which item
 840         --   it came from.  It's illegal to export two distinct things
 841         --   that have the same occurrence name
 842
 843 rnExports :: Bool       -- False => no 'module M(..) where' header at all
 844           -> Maybe [LIE RdrName]        -- Nothing => no explicit export list
 845           -> TcGblEnv
 846           -> RnM TcGblEnv
 847
 848         -- Complains if two distinct exports have same OccName
 849         -- Warns about identical exports.
 850         -- Complains about exports items not in scope
 851
 852 rnExports explicit_mod exports
 853           tcg_env@(TcGblEnv { tcg_mod     = this_mod,
 854                               tcg_rdr_env = rdr_env,
 855                               tcg_imports = imports })
 856  = do   {
 857         -- If the module header is omitted altogether, then behave
 858         -- as if the user had written "module Main(main) where..."
 859         -- EXCEPT in interactive mode, when we behave as if he had
 860         -- written "module Main where ..."
 861         -- Reason: don't want to complain about 'main' not in scope
 862         --         in interactive mode
 863         ; dflags <- getDOpts
 864         ; let real_exports
 865                  | explicit_mod = exports
 866                  | ghcLink dflags == LinkInMemory = Nothing
 867                  | otherwise = Just ([noLoc (IEVar main_RDR_Unqual)])
 868                         -- ToDo: the 'noLoc' here is unhelpful if 'main'
 869                         --       turns out to be out of scope
 870
 871         ; (rn_exports, avails) <- exports_from_avail real_exports rdr_env imports this_mod
 872         ; let final_avails = nubAvails avails        -- Combine families
 873
 874         ; return (tcg_env { tcg_exports    = final_avails,
 875                             tcg_rn_exports = case tcg_rn_exports tcg_env of
 876                                                 Nothing -> Nothing
 877                                                 Just _  -> rn_exports,
 878                             tcg_dus = tcg_dus tcg_env `plusDU`
 879                                       usesOnly (availsToNameSet final_avails) }) }
 880
 881 exports_from_avail :: Maybe [LIE RdrName]
 882                          -- Nothing => no explicit export list
 883                    -> GlobalRdrEnv
 884                    -> ImportAvails
 885                    -> Module
 886                    -> RnM (Maybe [LIE Name], [AvailInfo])
 887
 888 exports_from_avail Nothing rdr_env _imports _this_mod
 889  = -- The same as (module M) where M is the current module name,
 890    -- so that's how we handle it.
 891    let
 892        avails = [ greAvail gre | gre <- globalRdrEnvElts rdr_env,
 893                                  isLocalGRE gre ]
 894    in
 895    return (Nothing, avails)
 896
 897 exports_from_avail (Just rdr_items) rdr_env imports this_mod
 898   = do (ie_names, _, exports) <- foldlM do_litem emptyExportAccum rdr_items
 899
 900        return (Just ie_names, exports)
 901   where
 902     do_litem :: ExportAccum -> LIE RdrName -> RnM ExportAccum
 903     do_litem acc lie = setSrcSpan (getLoc lie) (exports_from_item acc lie)
 904
 905     kids_env :: NameEnv [Name]  -- Maps a parent to its in-scope children
 906     kids_env = mkChildEnv (globalRdrEnvElts rdr_env)
 907
 908     imported_modules = [ qual_name
 909                        | xs <- moduleEnvElts $ imp_mods imports,
 910                          (qual_name, _, _) <- xs ]
 911
 912     exports_from_item :: ExportAccum -> LIE RdrName -> RnM ExportAccum
 913     exports_from_item acc@(ie_names, occs, exports)
 914                       (L loc ie@(IEModuleContents mod))
 915         | let earlier_mods = [ mod | (L _ (IEModuleContents mod)) <- ie_names ]
 916         , mod `elem` earlier_mods       -- Duplicate export of M
 917         = do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ;
 918                warnIf warn_dup_exports (dupModuleExport mod) ;
 919                return acc }
 920
 921         | otherwise
 922         = do { implicit_prelude <- xoptM Opt_ImplicitPrelude
 923              ; warnDodgyExports <- doptM Opt_WarnDodgyExports
 924              ; let { exportValid = (mod `elem` imported_modules)
 925                             || (moduleName this_mod == mod)
 926                    ; gres = filter (isModuleExported implicit_prelude mod)
 927                                    (globalRdrEnvElts rdr_env)
 928                    ; names = map gre_name gres
 929                    }
 930
 931              ; checkErr exportValid (moduleNotImported mod)
 932              ; warnIf (warnDodgyExports && exportValid && null gres) (nullModuleExport mod)
 933
 934              ; addUsedRdrNames (concat [ [mkRdrQual mod occ, mkRdrUnqual occ]
 935                                        | occ <- map nameOccName names ])
 936                         -- The qualified and unqualified version of all of
 937                         -- these names are, in effect, used by this export
 938
 939              ; occs' <- check_occs ie occs names
 940                       -- This check_occs not only finds conflicts
 941                       -- between this item and others, but also
 942                       -- internally within this item.  That is, if
 943                       -- 'M.x' is in scope in several ways, we'll have
 944                       -- several members of mod_avails with the same
 945                       -- OccName.
 946              ; return (L loc (IEModuleContents mod) : ie_names,
 947                        occs', map greAvail gres ++ exports) }
 948
 949     exports_from_item acc@(lie_names, occs, exports) (L loc ie)
 950         | isDoc ie
 951         = do new_ie <- lookup_doc_ie ie
 952              return (L loc new_ie : lie_names, occs, exports)
 953
 954         | otherwise
 955         = do (new_ie, avail) <- lookup_ie ie
 956              if isUnboundName (ieName new_ie)
 957                   then return acc       -- Avoid error cascade
 958                   else do
 959
 960              occs' <- check_occs ie occs (availNames avail)
 961
 962              return (L loc new_ie : lie_names, occs', avail : exports)
 963
 964     -------------
 965     lookup_ie :: IE RdrName -> RnM (IE Name, AvailInfo)
 966     lookup_ie (IEVar rdr)
 967         = do gre <- lookupGreRn rdr
 968              return (IEVar (gre_name gre), greAvail gre)
 969
 970     lookup_ie (IEThingAbs rdr)
 971         = do gre <- lookupGreRn rdr
 972              let name = gre_name gre
 973              case gre_par gre of
 974                 NoParent   -> return (IEThingAbs name,
 975                                       AvailTC name [name])
 976                 ParentIs p -> return (IEThingAbs name,
 977                                       AvailTC p [name])
 978
 979     lookup_ie ie@(IEThingAll rdr)
 980         = do name <- lookupGlobalOccRn rdr
 981              let kids = findChildren kids_env name
 982                  mkKidRdrName = case isQual_maybe rdr of
 983                                 Nothing -> mkRdrUnqual
 984                                 Just (modName, _) -> mkRdrQual modName
 985              addUsedRdrNames $ map (mkKidRdrName . nameOccName) kids
 986              warnDodgyExports <- doptM Opt_WarnDodgyExports
 987              when (null kids) $
 988                   if isTyConName name
 989                   then when warnDodgyExports $ addWarn (dodgyExportWarn name)
 990                   else -- This occurs when you export T(..), but
 991                        -- only import T abstractly, or T is a synonym.
 992                        addErr (exportItemErr ie)
 993
 994              return (IEThingAll name, AvailTC name (name:kids))
 995
 996     lookup_ie ie@(IEThingWith rdr sub_rdrs)
 997         = do name <- lookupGlobalOccRn rdr
 998              if isUnboundName name
 999                 then return (IEThingWith name [], AvailTC name [name])
1000                 else do
1001              let env = mkOccEnv [ (nameOccName s, s)
1002                                 | s <- findChildren kids_env name ]
1003                  mb_names = map (lookupOccEnv env . rdrNameOcc) sub_rdrs
1004              if any isNothing mb_names
1005                 then do addErr (exportItemErr ie)
1006                         return (IEThingWith name [], AvailTC name [name])
1007                 else do let names = catMaybes mb_names
1008                         optTyFam <- xoptM Opt_TypeFamilies
1009                         when (not optTyFam && any isTyConName names) $
1010                           addErr (typeItemErr ( head
1011                                               . filter isTyConName
1012                                               $ names )
1013                                               (text "in export list"))
1014                         return (IEThingWith name names, AvailTC name (name:names))
1015
1016     lookup_ie _ = panic "lookup_ie"     -- Other cases covered earlier
1017
1018     -------------
1019     lookup_doc_ie :: IE RdrName -> RnM (IE Name)
1020     lookup_doc_ie (IEGroup lev doc) = do rn_doc <- rnHsDoc doc
1021                                          return (IEGroup lev rn_doc)
1022     lookup_doc_ie (IEDoc doc)       = do rn_doc <- rnHsDoc doc
1023                                          return (IEDoc rn_doc)
1024     lookup_doc_ie (IEDocNamed str)  = return (IEDocNamed str)
1025     lookup_doc_ie _ = panic "lookup_doc_ie"     -- Other cases covered earlier
1026
1027
1028 isDoc :: IE RdrName -> Bool
1029 isDoc (IEDoc _)      = True
1030 isDoc (IEDocNamed _) = True
1031 isDoc (IEGroup _ _)  = True
1032 isDoc _ = False
1033
1034 -------------------------------
1035 isModuleExported :: Bool -> ModuleName -> GlobalRdrElt -> Bool
1036 -- True if the thing is in scope *both* unqualified, *and* with qualifier M
1037 isModuleExported implicit_prelude mod (GRE { gre_name = name, gre_prov = prov })
1038   | implicit_prelude && isBuiltInSyntax name = False
1039         -- Optimisation: filter out names for built-in syntax
1040         -- They just clutter up the environment (esp tuples), and the parser
1041         -- will generate Exact RdrNames for them, so the cluttered
1042         -- envt is no use.  To avoid doing this filter all the time,
1043         -- we use -XNoImplicitPrelude as a clue that the filter is
1044         -- worth while.  Really, it's only useful for GHC.Base and GHC.Tuple.
1045         --
1046         -- It's worth doing because it makes the environment smaller for
1047         -- every module that imports the Prelude
1048   | otherwise
1049   = case prov of
1050         LocalDef | Just name_mod <- nameModule_maybe name
1051                  -> moduleName name_mod == mod
1052                  | otherwise -> False
1053         Imported is -> any unQualSpecOK is && any (qualSpecOK mod) is
1054
1055 -------------------------------
1056 check_occs :: IE RdrName -> ExportOccMap -> [Name] -> RnM ExportOccMap
1057 check_occs ie occs names
1058   = foldlM check occs names
1059   where
1060     check occs name
1061       = case lookupOccEnv occs name_occ of
1062           Nothing -> return (extendOccEnv occs name_occ (name, ie))
1063
1064           Just (name', ie')
1065             | name == name'     -- Duplicate export
1066             ->  do { warn_dup_exports <- doptM Opt_WarnDuplicateExports ;
1067                      warnIf warn_dup_exports (dupExportWarn name_occ ie ie') ;
1068                      return occs }
1069
1070             | otherwise         -- Same occ name but different names: an error
1071             ->  do { global_env <- getGlobalRdrEnv ;
1072                      addErr (exportClashErr global_env name' name ie' ie) ;
1073                      return occs }
1074       where
1075         name_occ = nameOccName name
1076 \end{code}
1077
1078 %*********************************************************
1079 %*                                                       *
1080                 Deprecations
1081 %*                                                       *
1082 %*********************************************************
1083
1084 \begin{code}
1085 finishWarnings :: DynFlags -> Maybe WarningTxt
1086                -> TcGblEnv -> RnM TcGblEnv
1087 -- (a) Report usage of imports that are deprecated or have other warnings
1088 -- (b) If the whole module is warned about or deprecated, update tcg_warns
1089 --     All this happens only once per module
1090 finishWarnings dflags mod_warn tcg_env
1091   = do  { (eps,hpt) <- getEpsAndHpt
1092         ; ifDOptM Opt_WarnWarningsDeprecations $
1093           mapM_ (check hpt (eps_PIT eps)) all_gres
1094                 -- By this time, typechecking is complete,
1095                 -- so the PIT is fully populated
1096
1097         -- Deal with a module deprecation; it overrides all existing warns
1098         ; let new_warns = case mod_warn of
1099                                 Just txt -> WarnAll txt
1100                                 Nothing  -> tcg_warns tcg_env
1101         ; return (tcg_env { tcg_warns = new_warns }) }
1102   where
1103     used_names = allUses (tcg_dus tcg_env)
1104         -- Report on all deprecated uses; hence allUses
1105     all_gres   = globalRdrEnvElts (tcg_rdr_env tcg_env)
1106
1107     check hpt pit gre@(GRE {gre_name = name, gre_prov = Imported (imp_spec:_)})
1108       | name `elemNameSet` used_names
1109       , Just deprec_txt <- lookupImpDeprec dflags hpt pit gre
1110       = addWarnAt (importSpecLoc imp_spec)
1111                   (sep [ptext (sLit "In the use of") <+>
1112                         pprNonVarNameSpace (occNameSpace (nameOccName name)) <+>
1113                         quotes (ppr name),
1114                       (parens imp_msg) <> colon,
1115                       (ppr deprec_txt) ])
1116         where
1117           name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1118           imp_mod  = importSpecModule imp_spec
1119           imp_msg  = ptext (sLit "imported from") <+> ppr imp_mod <> extra
1120           extra | imp_mod == moduleName name_mod = empty
1121                 | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod
1122
1123     check _ _ _ = return ()     -- Local, or not used, or not deprectated
1124             -- The Imported pattern-match: don't deprecate locally defined names
1125             -- For a start, we may be exporting a deprecated thing
1126             -- Also we may use a deprecated thing in the defn of another
1127             -- deprecated things.  We may even use a deprecated thing in
1128             -- the defn of a non-deprecated thing, when changing a module's
1129             -- interface
1130
1131 lookupImpDeprec :: DynFlags -> HomePackageTable -> PackageIfaceTable
1132                 -> GlobalRdrElt -> Maybe WarningTxt
1133 -- The name is definitely imported, so look in HPT, PIT
1134 lookupImpDeprec dflags hpt pit gre
1135   = case lookupIfaceByModule dflags hpt pit mod of
1136         Just iface -> mi_warn_fn iface name `mplus`     -- Bleat if the thing, *or
1137                       case gre_par gre of
1138                         ParentIs p -> mi_warn_fn iface p        -- its parent*, is warn'd
1139                         NoParent   -> Nothing
1140
1141         Nothing -> Nothing      -- See Note [Used names with interface not loaded]
1142   where
1143     name = gre_name gre
1144     mod = ASSERT2( isExternalName name, ppr name ) nameModule name
1145 \end{code}
1146
1147 Note [Used names with interface not loaded]
1148 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1149 By now all the interfaces should have been loaded,
1150 because reportDeprecations happens after typechecking.
1151 However, it's still (just) possible to to find a used
1152 Name whose interface hasn't been loaded:
1153
1154 a) It might be a WiredInName; in that case we may not load
1155    its interface (although we could).
1156
1157 b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
1158    These are seen as "used" by the renamer (if -XRebindableSyntax)
1159    is on), but the typechecker may discard their uses
1160    if in fact the in-scope fromRational is GHC.Read.fromRational,
1161    (see tcPat.tcOverloadedLit), and the typechecker sees that the type
1162    is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
1163    In that obscure case it won't force the interface in.
1164
1165 In both cases we simply don't permit deprecations;
1166 this is, after all, wired-in stuff.
1167
1168
1169 %*********************************************************
1170 %*                                                       *
1171                 Unused names
1172 %*                                                       *
1173 %*********************************************************
1174
1175 \begin{code}
1176 reportUnusedNames :: Maybe [LIE RdrName]        -- Export list
1177                   -> TcGblEnv -> RnM ()
1178 reportUnusedNames _export_decls gbl_env
1179   = do  { traceRn ((text "RUN") <+> (ppr (tcg_dus gbl_env)))
1180         ; warnUnusedImportDecls gbl_env
1181         ; warnUnusedTopBinds   unused_locals }
1182   where
1183     used_names :: NameSet
1184     used_names = findUses (tcg_dus gbl_env) emptyNameSet
1185         -- NB: currently, if f x = g, we only treat 'g' as used if 'f' is used
1186         -- Hence findUses
1187
1188         -- Collect the defined names from the in-scope environment
1189     defined_names :: [GlobalRdrElt]
1190     defined_names = globalRdrEnvElts (tcg_rdr_env gbl_env)
1191
1192         -- Note that defined_and_used, defined_but_not_used
1193         -- are both [GRE]; that's why we need defined_and_used
1194         -- rather than just used_names
1195     _defined_and_used, defined_but_not_used :: [GlobalRdrElt]
1196     (_defined_and_used, defined_but_not_used)
1197         = partition (gre_is_used used_names) defined_names
1198
1199     kids_env = mkChildEnv defined_names
1200         -- This is done in mkExports too; duplicated work
1201
1202     gre_is_used :: NameSet -> GlobalRdrElt -> Bool
1203     gre_is_used used_names (GRE {gre_name = name})
1204         = name `elemNameSet` used_names
1205           || any (`elemNameSet` used_names) (findChildren kids_env name)
1206                 -- A use of C implies a use of T,
1207                 -- if C was brought into scope by T(..) or T(C)
1208
1209         -- Filter out the ones that are
1210         --  (a) defined in this module, and
1211         --  (b) not defined by a 'deriving' clause
1212         -- The latter have an Internal Name, so we can filter them out easily
1213     unused_locals :: [GlobalRdrElt]
1214     unused_locals = filter is_unused_local defined_but_not_used
1215     is_unused_local :: GlobalRdrElt -> Bool
1216     is_unused_local gre = isLocalGRE gre && isExternalName (gre_name gre)
1217 \end{code}
1218
1219 %*********************************************************
1220 %*                                                       *
1221                 Unused imports
1222 %*                                                       *
1223 %*********************************************************
1224
1225 This code finds which import declarations are unused.  The
1226 specification and implementation notes are here:
1227   http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/UnusedImports
1228
1229 \begin{code}
1230 type ImportDeclUsage
1231    = ( LImportDecl Name   -- The import declaration
1232      , [AvailInfo]        -- What *is* used (normalised)
1233      , [Name] )           -- What is imported but *not* used
1234 \end{code}
1235
1236 \begin{code}
1237 warnUnusedImportDecls :: TcGblEnv -> RnM ()
1238 warnUnusedImportDecls gbl_env
1239   = do { uses <- readMutVar (tcg_used_rdrnames gbl_env)
1240        ; let imports = filter explicit_import (tcg_rn_imports gbl_env)
1241              rdr_env = tcg_rdr_env gbl_env
1242
1243        ; let usage :: [ImportDeclUsage]
1244              usage = findImportUsage imports rdr_env (Set.elems uses)
1245
1246        ; ifDOptM Opt_WarnUnusedImports $
1247          mapM_ warnUnusedImport usage
1248
1249        ; ifDOptM Opt_D_dump_minimal_imports $
1250          printMinimalImports usage }
1251   where
1252     explicit_import (L loc _) = isGoodSrcSpan loc
1253         -- Filter out the implicit Prelude import
1254         -- which we do not want to bleat about
1255 \end{code}
1256
1257 \begin{code}
1258 findImportUsage :: [LImportDecl Name]
1259                 -> GlobalRdrEnv
1260                 -> [RdrName]
1261                 -> [ImportDeclUsage]
1262
1263 type ImportMap = Map SrcLoc [AvailInfo]
1264   -- The intermediate data struture records, for each import
1265   -- declaration, what stuff brought into scope by that
1266   -- declaration is actually used in the module.
1267   --
1268   -- The SrcLoc is the location of the start
1269   -- of a particular 'import' declaration
1270   --
1271   -- The AvailInfos are the things imported from that decl
1272   -- (just a list, not normalised)
1273
1274 findImportUsage imports rdr_env rdrs
1275   = map unused_decl imports
1276   where
1277     import_usage :: ImportMap
1278     import_usage = foldr (addUsedRdrName rdr_env) Map.empty rdrs
1279
1280     unused_decl decl@(L loc (ImportDecl { ideclHiding = imps }))
1281       = (decl, nubAvails used_avails, unused_imps)
1282       where
1283         used_avails = Map.lookup (srcSpanStart loc) import_usage `orElse` []
1284         dont_report_as_unused = foldr add emptyNameSet used_avails
1285         add (Avail n) s = s `addOneToNameSet` n
1286         add (AvailTC n ns) s = s `addListToNameSet` (n:ns)
1287                 -- If you use 'signum' from Num, then the user may well have
1288                 -- imported Num(signum).  We don't want to complain that
1289                 -- Num is not itself mentioned.  Hence adding 'n' as
1290                 -- well to the list of of "don't report if unused" names
1291
1292         unused_imps = case imps of
1293                         Just (False, imp_ies) -> nameSetToList unused_imps
1294                           where
1295                             imp_names = mkNameSet (concatMap (ieNames . unLoc) imp_ies)
1296                             unused_imps = imp_names `minusNameSet` dont_report_as_unused
1297
1298                         _other -> []    -- No explicit import list => no unused-name list
1299
1300 addUsedRdrName :: GlobalRdrEnv -> RdrName -> ImportMap -> ImportMap
1301 -- For a used RdrName, find all the import decls that brought
1302 -- it into scope; choose one of them (bestImport), and record
1303 -- the RdrName in that import decl's entry in the ImportMap
1304 addUsedRdrName rdr_env rdr imp_map
1305   | [gre] <- lookupGRE_RdrName rdr rdr_env
1306   , Imported imps <- gre_prov gre
1307   = add_imp gre (bestImport imps) imp_map
1308   | otherwise
1309   = imp_map
1310   where
1311     add_imp :: GlobalRdrElt -> ImportSpec -> ImportMap -> ImportMap
1312     add_imp gre (ImpSpec { is_decl = imp_decl_spec }) imp_map
1313       = Map.insertWith add decl_loc [avail] imp_map
1314       where
1315         add _ avails = avail : avails -- add is really just a specialised (++)
1316         decl_loc = srcSpanStart (is_dloc imp_decl_spec)
1317         name     = gre_name gre
1318         avail    = case gre_par gre of
1319                       ParentIs p                  -> AvailTC p [name]
1320                       NoParent | isTyConName name -> AvailTC name [name]
1321                                | otherwise        -> Avail name
1322
1323     bestImport :: [ImportSpec] -> ImportSpec
1324     bestImport iss
1325       = case partition isImpAll iss of
1326           ([], imp_somes) -> textuallyFirst imp_somes
1327           (imp_alls, _)   -> textuallyFirst imp_alls
1328
1329     textuallyFirst :: [ImportSpec] -> ImportSpec
1330     textuallyFirst iss = case sortWith (is_dloc . is_decl) iss of
1331                         []     -> pprPanic "textuallyFirst" (ppr iss)
1332                         (is:_) -> is
1333
1334     isImpAll :: ImportSpec -> Bool
1335     isImpAll (ImpSpec { is_item = ImpAll }) = True
1336     isImpAll _other                         = False
1337 \end{code}
1338
1339 \begin{code}
1340 warnUnusedImport :: ImportDeclUsage -> RnM ()
1341 warnUnusedImport (L loc decl, used, unused)
1342   | Just (False,[]) <- ideclHiding decl
1343                 = return ()            -- Do not warn for 'import M()'
1344   | null used   = addWarnAt loc msg1   -- Nothing used; drop entire decl
1345   | null unused = return ()            -- Everything imported is used; nop
1346   | otherwise   = addWarnAt loc msg2   -- Some imports are unused
1347   where
1348     msg1 = vcat [pp_herald <+> quotes pp_mod <+> pp_not_used,
1349                  nest 2 (ptext (sLit "except perhaps to import instances from")
1350                                    <+> quotes pp_mod),
1351                  ptext (sLit "To import instances alone, use:")
1352                                    <+> ptext (sLit "import") <+> pp_mod <> parens empty ]
1353     msg2 = sep [pp_herald <+> quotes (pprWithCommas ppr unused),
1354                     text "from module" <+> quotes pp_mod <+> pp_not_used]
1355     pp_herald   = text "The import of"
1356     pp_mod      = ppr (unLoc (ideclName decl))
1357     pp_not_used = text "is redundant"
1358 \end{code}
1359
1360 To print the minimal imports we walk over the user-supplied import
1361 decls, and simply trim their import lists.  NB that
1362
1363   * We do *not* change the 'qualified' or 'as' parts!
1364
1365   * We do not disard a decl altogether; we might need instances
1366     from it.  Instead we just trim to an empty import list
1367
1368 \begin{code}
1369 printMinimalImports :: [ImportDeclUsage] -> RnM ()
1370 printMinimalImports imports_w_usage
1371   = do { imports' <- mapM mk_minimal imports_w_usage
1372        ; this_mod <- getModule
1373        ; liftIO $
1374          do { h <- openFile (mkFilename this_mod) WriteMode
1375             ; printForUser h neverQualify (vcat (map ppr imports')) }
1376                 -- The neverQualify is important.  We are printing Names
1377                 -- but they are in the context of an 'import' decl, and
1378                 -- we never qualify things inside there
1379                 -- E.g.   import Blag( f, b )
1380                 -- not    import Blag( Blag.f, Blag.g )!
1381        }
1382   where
1383     mkFilename this_mod = moduleNameString (moduleName this_mod) ++ ".imports"
1384
1385     mk_minimal (L l decl, used, unused)
1386       | null unused
1387       , Just (False, _) <- ideclHiding decl
1388       = return (L l decl)
1389       | otherwise
1390       = do { let ImportDecl { ideclName    = L _ mod_name
1391                             , ideclSource  = is_boot
1392                             , ideclPkgQual = mb_pkg } = decl
1393            ; iface <- loadSrcInterface doc mod_name is_boot mb_pkg
1394            ; let lies = map (L l) (concatMap (to_ie iface) used)
1395            ; return (L l (decl { ideclHiding = Just (False, lies) })) }
1396       where
1397         doc = text "Compute minimal imports for" <+> ppr decl
1398
1399     to_ie :: ModIface -> AvailInfo -> [IE Name]
1400         -- The main trick here is that if we're importing all the constructors
1401         -- we want to say "T(..)", but if we're importing only a subset we want
1402         -- to say "T(A,B,C)".  So we have to find out what the module exports.
1403     to_ie _ (Avail n)
1404        = [IEVar n]
1405     to_ie _ (AvailTC n [m])
1406        | n==m = [IEThingAbs n]
1407     to_ie iface (AvailTC n ns)
1408       = case [xs | (m,as) <- mi_exports iface
1409                  , m == n_mod
1410                  , AvailTC x xs <- as
1411                  , x == nameOccName n
1412                  , x `elem` xs  -- Note [Partial export]
1413                  ] of
1414            [xs] | all_used xs -> [IEThingAll n]
1415                 | otherwise   -> [IEThingWith n (filter (/= n) ns)]
1416            _other             -> (map IEVar ns)
1417         where
1418           all_used avail_occs = all (`elem` map nameOccName ns) avail_occs
1419           n_mod = ASSERT( isExternalName n ) nameModule n
1420 \end{code}
1421
1422 Note [Partial export]
1423 ~~~~~~~~~~~~~~~~~~~~~
1424 Suppose we have
1425
1426    module A( op ) where
1427      class C a where
1428        op :: a -> a
1429
1430    module B where
1431    import A
1432    f = ..op...
1433
1434 Then the minimal import for module B is
1435    import A( op )
1436 not
1437    import A( C( op ) )
1438 which we would usually generate if C was exported from B.  Hence
1439 the (x `elem` xs) test when deciding what to generate.
1440
1441
1442 %************************************************************************
1443 %*                                                                      *
1444 \subsection{Errors}
1445 %*                                                                      *
1446 %************************************************************************
1447
1448 \begin{code}
1449 qualImportItemErr :: RdrName -> SDoc
1450 qualImportItemErr rdr
1451   = hang (ptext (sLit "Illegal qualified name in import item:"))
1452        2 (ppr rdr)
1453
1454 badImportItemErr :: ModIface -> ImpDeclSpec -> IE RdrName -> SDoc
1455 badImportItemErr iface decl_spec ie
1456   = sep [ptext (sLit "Module"), quotes (ppr (is_mod decl_spec)), source_import,
1457          ptext (sLit "does not export"), quotes (ppr ie)]
1458   where
1459     source_import | mi_boot iface = ptext (sLit "(hi-boot interface)")
1460                   | otherwise     = empty
1461
1462 illegalImportItemErr :: SDoc
1463 illegalImportItemErr = ptext (sLit "Illegal import item")
1464
1465 dodgyImportWarn :: RdrName -> SDoc
1466 dodgyImportWarn item = dodgyMsg (ptext (sLit "import")) item
1467 dodgyExportWarn :: Name -> SDoc
1468 dodgyExportWarn item = dodgyMsg (ptext (sLit "export")) item
1469
1470 dodgyMsg :: OutputableBndr n => SDoc -> n -> SDoc
1471 dodgyMsg kind tc
1472   = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc))
1473                 <+> ptext (sLit "suggests that"),
1474           quotes (ppr tc) <+> ptext (sLit "has (in-scope) constructors or class methods,"),
1475           ptext (sLit "but it has none") ]
1476
1477 exportItemErr :: IE RdrName -> SDoc
1478 exportItemErr export_item
1479   = sep [ ptext (sLit "The export item") <+> quotes (ppr export_item),
1480           ptext (sLit "attempts to export constructors or class methods that are not visible here") ]
1481
1482 typeItemErr :: Name -> SDoc -> SDoc
1483 typeItemErr name wherestr
1484   = sep [ ptext (sLit "Using 'type' tag on") <+> quotes (ppr name) <+> wherestr,
1485           ptext (sLit "Use -XTypeFamilies to enable this extension") ]
1486
1487 exportClashErr :: GlobalRdrEnv -> Name -> Name -> IE RdrName -> IE RdrName
1488                -> Message
1489 exportClashErr global_env name1 name2 ie1 ie2
1490   = vcat [ ptext (sLit "Conflicting exports for") <+> quotes (ppr occ) <> colon
1491          , ppr_export ie1' name1'
1492          , ppr_export ie2' name2' ]
1493   where
1494     occ = nameOccName name1
1495     ppr_export ie name = nest 2 (quotes (ppr ie) <+> ptext (sLit "exports") <+>
1496                                  quotes (ppr name) <+> pprNameProvenance (get_gre name))
1497
1498         -- get_gre finds a GRE for the Name, so that we can show its provenance
1499     get_gre name
1500         = case lookupGRE_Name global_env name of
1501              (gre:_) -> gre
1502              []      -> pprPanic "exportClashErr" (ppr name)
1503     get_loc name = greSrcSpan (get_gre name)
1504     (name1', ie1', name2', ie2') = if get_loc name1 < get_loc name2
1505                                    then (name1, ie1, name2, ie2)
1506                                    else (name2, ie2, name1, ie1)
1507
1508 -- the SrcSpan that pprNameProvenance prints out depends on whether
1509 -- the Name is defined locally or not: for a local definition the
1510 -- definition site is used, otherwise the location of the import
1511 -- declaration.  We want to sort the export locations in
1512 -- exportClashErr by this SrcSpan, we need to extract it:
1513 greSrcSpan :: GlobalRdrElt -> SrcSpan
1514 greSrcSpan gre
1515   | Imported (is:_) <- gre_prov gre = is_dloc (is_decl is)
1516   | otherwise                       = name_span
1517   where
1518     name_span = nameSrcSpan (gre_name gre)
1519
1520 addDupDeclErr :: [Name] -> TcRn ()
1521 addDupDeclErr []
1522   = panic "addDupDeclErr: empty list"
1523 addDupDeclErr names@(name : _)
1524   = addErrAt (getSrcSpan (last sorted_names)) $
1525         -- Report the error at the later location
1526     vcat [ptext (sLit "Multiple declarations of") <+> quotes (ppr name),
1527           ptext (sLit "Declared at:") <+> vcat (map (ppr . nameSrcLoc) sorted_names)]
1528   where
1529     sorted_names = sortWith nameSrcLoc names
1530
1531 dupExportWarn :: OccName -> IE RdrName -> IE RdrName -> SDoc
1532 dupExportWarn occ_name ie1 ie2
1533   = hsep [quotes (ppr occ_name),
1534           ptext (sLit "is exported by"), quotes (ppr ie1),
1535           ptext (sLit "and"),            quotes (ppr ie2)]
1536
1537 dupModuleExport :: ModuleName -> SDoc
1538 dupModuleExport mod
1539   = hsep [ptext (sLit "Duplicate"),
1540           quotes (ptext (sLit "Module") <+> ppr mod),
1541           ptext (sLit "in export list")]
1542
1543 moduleNotImported :: ModuleName -> SDoc
1544 moduleNotImported mod
1545   = ptext (sLit "The export item `module") <+> ppr mod <>
1546     ptext (sLit "' is not imported")
1547
1548 nullModuleExport :: ModuleName -> SDoc
1549 nullModuleExport mod
1550   = ptext (sLit "The export item `module") <+> ppr mod <> ptext (sLit "' exports nothing")
1551
1552 missingImportListWarn :: ModuleName -> SDoc
1553 missingImportListWarn mod
1554   = ptext (sLit "The module") <+> quotes (ppr mod) <+> ptext (sLit "does not have an explicit import list")
1555
1556 missingImportListItem :: IE RdrName -> SDoc
1557 missingImportListItem ie
1558   = ptext (sLit "The import item") <+> quotes (ppr ie) <+> ptext (sLit "does not have an explicit import list")
1559
1560 moduleWarn :: ModuleName -> WarningTxt -> SDoc
1561 moduleWarn mod (WarningTxt txt)
1562   = sep [ ptext (sLit "Module") <+> quotes (ppr mod) <> ptext (sLit ":"),
1563           nest 2 (vcat (map ppr txt)) ]
1564 moduleWarn mod (DeprecatedTxt txt)
1565   = sep [ ptext (sLit "Module") <+> quotes (ppr mod)
1566                                 <+> ptext (sLit "is deprecated:"),
1567           nest 2 (vcat (map ppr txt)) ]
1568
1569 implicitPreludeWarn :: SDoc
1570 implicitPreludeWarn
1571   = ptext (sLit "Module `Prelude' implicitly imported")
1572
1573 packageImportErr :: SDoc
1574 packageImportErr
1575   = ptext (sLit "Package-qualified imports are not enabled; use -XPackageImports")
1576 \end{code}