RnEnv.hs 82.9 KB
Newer Older
Austin Seipp's avatar
Austin Seipp committed
1 2 3
{-
(c) The GRASP/AQUA Project, Glasgow University, 1992-2006

4
\section[RnEnv]{Environment manipulation for the renamer monad}
Austin Seipp's avatar
Austin Seipp committed
5
-}
6

7 8
{-# LANGUAGE CPP #-}

Ian Lynagh's avatar
Ian Lynagh committed
9 10 11
module RnEnv (
        newTopSrcBinder,
        lookupLocatedTopBndrRn, lookupTopBndrRn,
12
        lookupLocatedOccRn, lookupOccRn, lookupOccRn_maybe,
13
        lookupLocalOccRn_maybe, lookupInfoOccRn,
gmainland's avatar
gmainland committed
14
        lookupLocalOccThLvl_maybe,
Ian Lynagh's avatar
Ian Lynagh committed
15
        lookupTypeOccRn, lookupKindOccRn,
16
        lookupGlobalOccRn, lookupGlobalOccRn_maybe,
Adam Gundry's avatar
Adam Gundry committed
17
        lookupOccRn_overloaded, lookupGlobalOccRn_overloaded,
18
        reportUnboundName, unknownNameSuggestions,
19
        addNameClashErrRn,
20

Ian Lynagh's avatar
Ian Lynagh committed
21
        HsSigCtxt(..), lookupLocalTcNames, lookupSigOccRn,
22
        lookupSigCtxtOccRn,
23

Ian Lynagh's avatar
Ian Lynagh committed
24 25
        lookupFixityRn, lookupTyFixityRn,
        lookupInstDeclBndr, lookupSubBndrOcc, lookupFamInstName,
26
        lookupSubBndrGREs, lookupConstructorFields,
27
        lookupSyntaxName, lookupSyntaxNames, lookupIfThenElse,
28
        lookupGreAvailRn,
29 30
        getLookupOccRn,
        addUsedGRE, addUsedGREs, addUsedDataCons,
Ian Lynagh's avatar
Ian Lynagh committed
31 32

        newLocalBndrRn, newLocalBndrsRn,
33
        bindLocalNames, bindLocalNamesFV,
Austin Seipp's avatar
Austin Seipp committed
34
        MiniFixityEnv,
Ian Lynagh's avatar
Ian Lynagh committed
35 36 37 38 39
        addLocalFixities,
        bindLocatedLocalsFV, bindLocatedLocalsRn,
        extendTyVarEnvFVRn,

        checkDupRdrNames, checkShadowedRdrNames,
40
        checkDupNames, checkDupAndShadowedNames, checkTupSize,
Ian Lynagh's avatar
Ian Lynagh committed
41 42 43
        addFvRn, mapFvRn, mapMaybeFvRn, mapFvRnCPS,
        warnUnusedMatches,
        warnUnusedTopBinds, warnUnusedLocalBinds,
Adam Gundry's avatar
Adam Gundry committed
44 45
        mkFieldEnv,
        dataTcOccs, kindSigErr, perhapsForallMsg, unknownSubordinateErr,
46
        HsDocContext(..), docOfHsDocContext
47
    ) where
48

49
#include "HsVersions.h"
50

51
import LoadIface        ( loadInterfaceForName, loadSrcInterface_maybe )
52
import IfaceEnv
Ian Lynagh's avatar
Ian Lynagh committed
53
import HsSyn
54
import RdrName
55
import HscTypes
Adam Gundry's avatar
Adam Gundry committed
56
import TcEnv
57
import TcRnMonad
58
import RdrHsSyn         ( setRdrNameSpace )
59
import Name
60
import NameSet
61
import NameEnv
62
import Avail
63
import Module
cactus's avatar
cactus committed
64
import ConLike
Adam Gundry's avatar
Adam Gundry committed
65 66
import DataCon
import TyCon
67
import PrelNames        ( mkUnboundName, isUnboundName, rOOT_MAIN, forall_tv_RDR )
Ian Lynagh's avatar
Ian Lynagh committed
68
import ErrUtils         ( MsgDoc )
69
import BasicTypes       ( Fixity(..), FixityDirection(..), minPrecedence, defaultFixity )
Ian Lynagh's avatar
Ian Lynagh committed
70
import SrcLoc
71
import Outputable
72
import Util
73
import Maybes
74
import BasicTypes       ( TopLevelFlag(..) )
Ian Lynagh's avatar
Ian Lynagh committed
75
import ListSetOps       ( removeDups )
76
import DynFlags
77
import FastString
Ian Lynagh's avatar
Ian Lynagh committed
78
import Control.Monad
79
import Data.List
80
import ListSetOps       ( minusList )
Ian Lynagh's avatar
Ian Lynagh committed
81
import Constants        ( mAX_TUPLE_SIZE )
Ian Lynagh's avatar
Ian Lynagh committed
82

Austin Seipp's avatar
Austin Seipp committed
83 84 85
{-
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
86
                Source-code binders
Austin Seipp's avatar
Austin Seipp committed
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
Note [Signature lazy interface loading]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

GHC's lazy interface loading can be a bit confusing, so this Note is an
empirical description of what happens in one interesting case. When
compiling a signature module against an its implementation, we do NOT
load interface files associated with its names until after the type
checking phase.  For example:

    module ASig where
        data T
        f :: T -> T

Suppose we compile this with -sig-of "A is ASig":

    module B where
        data T = T
        f T = T

    module A(module B) where
        import B

During type checking, we'll load A.hi because we need to know what the
RdrEnv for the module is, but we DO NOT load the interface for B.hi!
It's wholly unnecessary: our local definition 'data T' in ASig is all
the information we need to finish type checking.  This is contrast to
type checking of ordinary Haskell files, in which we would not have the
local definition "data T" and would need to consult B.hi immediately.
(Also, this situation never occurs for hs-boot files, since you're not
allowed to reexport from another module.)

After type checking, we then check that the types we provided are
consistent with the backing implementation (in checkHiBootOrHsigIface).
At this point, B.hi is loaded, because we need something to compare
against.

I discovered this behavior when trying to figure out why type class
instances for Data.Map weren't in the EPS when I was type checking a
test very much like ASig (sigof02dm): the associated interface hadn't
been loaded yet!  (The larger issue is a moot point, since an instance
declared in a signature can never be a duplicate.)

This behavior might change in the future.  Consider this
alternate module B:

    module B where
        {-# DEPRECATED T, f "Don't use" #-}
        data T = T
        f T = T

One might conceivably want to report deprecation warnings when compiling
ASig with -sig-of B, in which case we need to look at B.hi to find the
deprecation warnings during renaming.  At the moment, you don't get any
warning until you use the identifier further downstream.  This would
144
require adjusting addUsedGRE so that during signature compilation,
145 146
we do not report deprecation warnings for LocalDef.  See also
Note [Handling of deprecations]
Austin Seipp's avatar
Austin Seipp committed
147
-}
148

149 150
newTopSrcBinder :: Located RdrName -> RnM Name
newTopSrcBinder (L loc rdr_name)
151
  | Just name <- isExact_maybe rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
152 153 154 155 156 157 158 159 160
  =     -- This is here to catch
        --   (a) Exact-name binders created by Template Haskell
        --   (b) The PrelBase defn of (say) [] and similar, for which
        --       the parser reads the special syntax and returns an Exact RdrName
        -- We are at a binding site for the name, so check first that it
        -- the current module is the correct one; otherwise GHC can get
        -- very confused indeed. This test rejects code like
        --      data T = (,) Int Int
        -- unless we are in GHC.Tup
161 162 163
    if isExternalName name then
      do { this_mod <- getModule
         ; unless (this_mod == nameModule name)
Ian Lynagh's avatar
Ian Lynagh committed
164
                  (addErrAt loc (badOrigBinding rdr_name))
165 166
         ; return name }
    else   -- See Note [Binders in Template Haskell] in Convert.hs
167 168
      do { this_mod <- getModule
         ; externaliseName this_mod name }
169

Simon Marlow's avatar
Simon Marlow committed
170
  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
171
  = do  { this_mod <- getModule
172
        ; unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
Ian Lynagh's avatar
Ian Lynagh committed
173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
                 (addErrAt loc (badOrigBinding rdr_name))
        -- When reading External Core we get Orig names as binders,
        -- but they should agree with the module gotten from the monad
        --
        -- We can get built-in syntax showing up here too, sadly.  If you type
        --      data T = (,,,)
        -- the constructor is parsed as a type, and then RdrHsSyn.tyConToDataCon
        -- uses setRdrNameSpace to make it into a data constructors.  At that point
        -- the nice Exact name for the TyCon gets swizzled to an Orig name.
        -- Hence the badOrigBinding error message.
        --
        -- Except for the ":Main.main = ..." definition inserted into
        -- the Main module; ugh!

        -- Because of this latter case, we call newGlobalBinder with a module from
        -- the RdrName, not from the environment.  In principle, it'd be fine to
        -- have an arbitrary mixture of external core definitions in a single module,
        -- (apart from module-initialisation issues, perhaps).
        ; newGlobalBinder rdr_mod rdr_occ loc }
192 193

  | otherwise
Ian Lynagh's avatar
Ian Lynagh committed
194 195 196 197 198 199
  = do  { unless (not (isQual rdr_name))
                 (addErrAt loc (badQualBndrErr rdr_name))
                -- Binders should not be qualified; if they are, and with a different
                -- module name, we we get a confusing "M.T is not in scope" error later

        ; stage <- getStage
200
        ; env <- getGblEnv
Ian Lynagh's avatar
Ian Lynagh committed
201 202 203 204 205
        ; if isBrackStage stage then
                -- We are inside a TH bracket, so make an *Internal* name
                -- See Note [Top-level Names in Template Haskell decl quotes] in RnNames
             do { uniq <- newUnique
                ; return (mkInternalName uniq (rdrNameOcc rdr_name) loc) }
206 207 208 209 210 211 212 213 214 215
          else case tcg_impl_rdr_env env of
            Just gr ->
                -- We're compiling --sig-of, so resolve with respect to this
                -- module.
                -- See Note [Signature parameters in TcGblEnv and DynFlags]
             do { case lookupGlobalRdrEnv gr (rdrNameOcc rdr_name) of
                    -- Be sure to override the loc so that we get accurate
                    -- information later
                    [GRE{ gre_name = n }] -> do
                      -- NB: Just adding this line will not work:
216
                      --    addUsedGRE True gre
217 218 219 220 221 222 223 224 225 226 227 228 229
                      -- see Note [Signature lazy interface loading] for
                      -- more details.
                      return (setNameLoc n loc)
                    _ -> do
                      { -- NB: cannot use reportUnboundName rdr_name
                        -- because it looks up in the wrong RdrEnv
                        -- ToDo: more helpful error messages
                      ; addErr (unknownNameErr (pprNonVarNameSpace
                            (occNameSpace (rdrNameOcc rdr_name))) rdr_name)
                      ; return (mkUnboundName rdr_name)
                      }
                }
            Nothing ->
Ian Lynagh's avatar
Ian Lynagh committed
230
                -- Normal case
231
             do { this_mod <- getModule
232
                ; traceRn (text "newTopSrcBinder" <+> (ppr this_mod $$ ppr rdr_name $$ ppr loc))
233
                ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc } }
234

Austin Seipp's avatar
Austin Seipp committed
235 236 237
{-
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
238
        Source code occurrences
Austin Seipp's avatar
Austin Seipp committed
239 240
*                                                      *
*********************************************************
241 242 243

Looking up a name in the RnEnv.

244 245 246 247 248 249 250 251 252 253 254
Note [Type and class operator definitions]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We want to reject all of these unless we have -XTypeOperators (Trac #3265)
   data a :*: b  = ...
   class a :*: b where ...
   data (:*:) a b  = ....
   class (:*:) a b where ...
The latter two mean that we are not just looking for a
*syntactically-infix* declaration, but one that uses an operator
OccName.  We use OccName.isSymOcc to detect that case, which isn't
terribly efficient, but there seems to be no better way.
Austin Seipp's avatar
Austin Seipp committed
255
-}
256

257 258
lookupTopBndrRn :: RdrName -> RnM Name
lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
Ian Lynagh's avatar
Ian Lynagh committed
259
                       case nopt of
260
                         Just n' -> return n'
261
                         Nothing -> do traceRn $ (text "lookupTopBndrRn fail" <+> ppr n)
262
                                       unboundName WL_LocalTop n
263

264 265 266
lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn

267
lookupTopBndrRn_maybe :: RdrName -> RnM (Maybe Name)
268
-- Look up a top-level source-code binder.   We may be looking up an unqualified 'f',
269
-- and there may be several imported 'f's too, which must not confuse us.
270
-- For example, this is OK:
Ian Lynagh's avatar
Ian Lynagh committed
271 272 273
--      import Foo( f )
--      infix 9 f       -- The 'f' here does not need to be qualified
--      f x = x         -- Nor here, of course
274
-- So we have to filter out the non-local ones.
275
--
276 277
-- A separate function (importsFromLocalDecls) reports duplicate top level
-- decls, so here it's safe just to choose an arbitrary one.
278
--
279 280
-- There should never be a qualified name in a binding position in Haskell,
-- but there can be if we have read in an external-Core file.
Ian Lynagh's avatar
Ian Lynagh committed
281
-- The Haskell parser checks for the illegal qualified name in Haskell
282
-- source files, so we don't need to do so here.
283

284
lookupTopBndrRn_maybe rdr_name
285
  | Just name <- isExact_maybe rdr_name
286
  = do { name' <- lookupExactOcc name; return (Just name') }
287

Ian Lynagh's avatar
Ian Lynagh committed
288 289 290 291 292 293
  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
        -- This deals with the case of derived bindings, where
        -- we don't bother to call newTopSrcBinder first
        -- We assume there is no "parent" name
  = do  { loc <- getSrcSpanM
        ; n <- newGlobalBinder rdr_mod rdr_occ loc
294
        ; return (Just n)}
295 296

  | otherwise
Ian Lynagh's avatar
Ian Lynagh committed
297
  = do  {  -- Check for operators in type or class declarations
298 299 300
           -- See Note [Type and class operator definitions]
          let occ = rdrNameOcc rdr_name
        ; when (isTcOcc occ && isSymOcc occ)
301
               (do { op_ok <- xoptM Opt_TypeOperators
Ian Lynagh's avatar
Ian Lynagh committed
302 303
                   ; unless op_ok (addErr (opDeclErr rdr_name)) })

304 305 306 307 308
        ; env <- getGlobalRdrEnv
        ; case filter isLocalGRE (lookupGRE_RdrName rdr_name env) of
            [gre] -> return (Just (gre_name gre))
            _     -> return Nothing  -- Ambiguous (can't happen) or unbound
    }
309

310
-----------------------------------------------
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
311 312
-- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].
-- This adds an error if the name cannot be found.
313 314
lookupExactOcc :: Name -> RnM Name
lookupExactOcc name
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
315 316 317 318 319 320 321 322 323 324 325
  = do { result <- lookupExactOcc_either name
       ; case result of
           Left err -> do { addErr err
                          ; return name }
           Right name' -> return name' }

-- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].
-- This never adds an error, but it may return one.
lookupExactOcc_either :: Name -> RnM (Either MsgDoc Name)
-- See Note [Looking up Exact RdrNames]
lookupExactOcc_either name
326 327
  | Just thing <- wiredInNameTyThing_maybe name
  , Just tycon <- case thing of
cactus's avatar
cactus committed
328 329 330
                    ATyCon tc                 -> Just tc
                    AConLike (RealDataCon dc) -> Just (dataConTyCon dc)
                    _                         -> Nothing
331 332
  , isTupleTyCon tycon
  = do { checkTupSize (tyConArity tycon)
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
333
       ; return (Right name) }
334

Ian Lynagh's avatar
Ian Lynagh committed
335
  | isExternalName name
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
336
  = return (Right name)
337

Ian Lynagh's avatar
Ian Lynagh committed
338
  | otherwise
339
  = do { env <- getGlobalRdrEnv
Ian Lynagh's avatar
Ian Lynagh committed
340
       ; let -- See Note [Splicing Exact names]
341 342 343 344 345 346
             main_occ =  nameOccName name
             demoted_occs = case demoteOccName main_occ of
                              Just occ -> [occ]
                              Nothing  -> []
             gres = [ gre | occ <- main_occ : demoted_occs
                          , gre <- lookupGlobalRdrEnv env occ
Ian Lynagh's avatar
Ian Lynagh committed
347
                          , gre_name gre == name ]
348
       ; case gres of
349 350
           [gre] -> return (Right (gre_name gre))

351 352
           []    -> -- See Note [Splicing Exact names]
                    do { lcl_env <- getLocalRdrEnv
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
353 354 355
                       ; if name `inLocalRdrEnvScope` lcl_env
                         then return (Right name)
                         else
356 357 358
#ifdef GHCI
                         do { th_topnames_var <- fmap tcg_th_topnames getGblEnv
                            ; th_topnames <- readTcRef th_topnames_var
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
359 360 361
                            ; if name `elemNameSet` th_topnames
                              then return (Right name)
                              else return (Left exact_nm_err)
362 363
                            }
#else /* !GHCI */
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
364
                         return (Left exact_nm_err)
365 366
#endif /* !GHCI */
                       }
367
           gres -> return (Left (sameNameErr gres))   -- Ugh!  See Note [Template Haskell ambiguity]
368
       }
369 370
  where
    exact_nm_err = hang (ptext (sLit "The exact Name") <+> quotes (ppr name) <+> ptext (sLit "is not in scope"))
371 372
                      2 (vcat [ ptext (sLit "Probable cause: you used a unique Template Haskell name (NameU), ")
                              , ptext (sLit "perhaps via newName, but did not bind it")
373
                              , ptext (sLit "If that's it, then -ddump-splices might be useful") ])
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390

sameNameErr :: [GlobalRdrElt] -> MsgDoc
sameNameErr [] = panic "addSameNameErr: empty list"
sameNameErr gres@(_ : _)
  = hang (ptext (sLit "Same exact name in multiple name-spaces:"))
       2 (vcat (map pp_one sorted_names) $$ th_hint)
  where
    sorted_names = sortWith nameSrcLoc (map gre_name gres)
    pp_one name
      = hang (pprNameSpace (occNameSpace (getOccName name))
              <+> quotes (ppr name) <> comma)
           2 (ptext (sLit "declared at:") <+> ppr (nameSrcLoc name))

    th_hint = vcat [ ptext (sLit "Probable cause: you bound a unique Template Haskell name (NameU),")
                   , ptext (sLit "perhaps via newName, in different name-spaces.")
                   , ptext (sLit "If that's it, then -ddump-splices might be useful") ]

391

392
-----------------------------------------------
393
lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
Ian Lynagh's avatar
Ian Lynagh committed
394
-- This is called on the method name on the left-hand side of an
395 396 397 398 399
-- instance declaration binding. eg.  instance Functor T where
--                                       fmap = ...
--                                       ^^^^ called on this
-- Regardless of how many unqualified fmaps are in scope, we want
-- the one that comes from the Functor class.
400
--
Ian Lynagh's avatar
Ian Lynagh committed
401
-- Furthermore, note that we take no account of whether the
402 403 404
-- name is only in scope qualified.  I.e. even if method op is
-- in scope as M.op, we still allow plain 'op' on the LHS of
-- an instance decl
405 406 407 408
--
-- The "what" parameter says "method" or "associated type",
-- depending on what we are looking up
lookupInstDeclBndr cls what rdr
409
  = do { when (isQual rdr)
Ian Lynagh's avatar
Ian Lynagh committed
410 411 412 413
              (addErr (badQualBndrErr rdr))
                -- In an instance decl you aren't allowed
                -- to use a qualified name for the method
                -- (Although it'd make perfect sense.)
414 415 416 417
       ; lookupSubBndrOcc False -- False => we don't give deprecated
                                -- warnings when a deprecated class
                                -- method is defined. We only warn
                                -- when it's used
Adam Gundry's avatar
Adam Gundry committed
418
                          (Just cls) doc rdr }
419
  where
420
    doc = what <+> ptext (sLit "of class") <+> quotes (ppr cls)
421

422 423

-----------------------------------------------
424
lookupFamInstName :: Maybe Name -> Located RdrName -> RnM (Located Name)
Ian Lynagh's avatar
Ian Lynagh committed
425
-- Used for TyData and TySynonym family instances only,
426
-- See Note [Family instance binders]
427
lookupFamInstName (Just cls) tc_rdr  -- Associated type; c.f RnBinds.rnMethodBind
428
  = wrapLocM (lookupInstDeclBndr cls (ptext (sLit "associated type"))) tc_rdr
429
lookupFamInstName Nothing tc_rdr     -- Family instance; tc_rdr is an *occurrence*
Ian Lynagh's avatar
Ian Lynagh committed
430
  = lookupLocatedOccRn tc_rdr
431

432
-----------------------------------------------
Adam Gundry's avatar
Adam Gundry committed
433
lookupConstructorFields :: Name -> RnM [FieldLabel]
434
-- Look up the fields of a given constructor
Ian Lynagh's avatar
Ian Lynagh committed
435 436 437 438 439 440 441
--   *  For constructors from this module, use the record field env,
--      which is itself gathered from the (as yet un-typechecked)
--      data type decls
--
--    * For constructors from imported modules, use the *type* environment
--      since imported modles are already compiled, the info is conveniently
--      right there
442 443

lookupConstructorFields con_name
Ian Lynagh's avatar
Ian Lynagh committed
444 445
  = do  { this_mod <- getModule
        ; if nameIsLocalOrFrom this_mod con_name then
Adam Gundry's avatar
Adam Gundry committed
446
          do { field_env <- getRecFieldEnv
Ian Lynagh's avatar
Ian Lynagh committed
447 448 449 450
             ; return (lookupNameEnv field_env con_name `orElse` []) }
          else
          do { con <- tcLookupDataCon con_name
             ; return (dataConFieldLabels con) } }
451 452

-----------------------------------------------
453 454 455 456
-- Used for record construction and pattern matching
-- When the -XDisambiguateRecordFields flag is on, take account of the
-- constructor name to disambiguate which field to use; it's just the
-- same as for instance decls
Ian Lynagh's avatar
Ian Lynagh committed
457
--
458
-- NB: Consider this:
Ian Lynagh's avatar
Ian Lynagh committed
459 460
--      module Foo where { data R = R { fld :: Int } }
--      module Odd where { import Foo; fld x = x { fld = 3 } }
461 462 463
-- Arguably this should work, because the reference to 'fld' is
-- unambiguous because there is only one field id 'fld' in scope.
-- But currently it's rejected.
464
lookupSubBndrOcc :: Bool
Adam Gundry's avatar
Adam Gundry committed
465 466
                 -> Maybe Name  -- Nothing => just look it up as usual
                                -- Just p  => use parent p to disambiguate
Ian Lynagh's avatar
Ian Lynagh committed
467
                 -> SDoc -> RdrName
468
                 -> RnM Name
469
lookupSubBndrOcc warnIfDeprec parent doc rdr_name
470
  | Just n <- isExact_maybe rdr_name   -- This happens in derived code
471
  = lookupExactOcc n
472 473 474 475

  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
  = lookupOrig rdr_mod rdr_occ

Ian Lynagh's avatar
Ian Lynagh committed
476 477 478 479 480 481 482
  | otherwise   -- Find all the things the rdr-name maps to
  = do  {       -- and pick the one with the right parent namep
          env <- getGlobalRdrEnv
        ; case lookupSubBndrGREs env parent rdr_name of
                -- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
                --     The latter does pickGREs, but we want to allow 'x'
                --     even if only 'M.x' is in scope
483
            [gre] -> do { addUsedGRE warnIfDeprec gre
484
                          -- Add a usage; this is an *occurrence* site
485
                          -- Note [Usage for sub-bndrs]
486
                        ; return (gre_name gre) }
487 488 489 490 491 492 493
            []    -> do { ns <- lookupQualifiedNameGHCi rdr_name
                        ; case ns of {
                                (n:_) -> return n ;
                                -- Unlikely to be more than one...?
                                [] -> do
                        { addErr (unknownSubordinateErr doc rdr_name)
                        ; return (mkUnboundName rdr_name) } } }
Ian Lynagh's avatar
Ian Lynagh committed
494 495
            gres  -> do { addNameClashErrRn rdr_name gres
                        ; return (gre_name (head gres)) } }
496

Adam Gundry's avatar
Adam Gundry committed
497 498 499
lookupSubBndrGREs :: GlobalRdrEnv -> Maybe Name -> RdrName -> [GlobalRdrElt]
-- If parent = Nothing, just do a normal lookup
-- If parent = Just p then find all GREs that
500 501 502 503 504
--   (a) have parent p
--   (b) for Unqual, are in scope qualified or unqualified
--       for Qual, are in scope with that qualification
lookupSubBndrGREs env parent rdr_name
  = case parent of
Adam Gundry's avatar
Adam Gundry committed
505 506
      Nothing               -> pickGREs rdr_name gres
      Just p
507 508 509 510 511 512
        | isUnqual rdr_name -> filter (parent_is p) gres
        | otherwise         -> filter (parent_is p) (pickGREs rdr_name gres)

  where
    gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)

Adam Gundry's avatar
Adam Gundry committed
513 514 515
    parent_is p (GRE { gre_par = ParentIs p' })             = p == p'
    parent_is p (GRE { gre_par = FldParent { par_is = p'}}) = p == p'
    parent_is _ _                                           = False
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
516

Austin Seipp's avatar
Austin Seipp committed
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
Note [Family instance binders]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
  data family F a
  data instance F T = X1 | X2

The 'data instance' decl has an *occurrence* of F (and T), and *binds*
X1 and X2.  (This is unlike a normal data type declaration which would
bind F too.)  So we want an AvailTC F [X1,X2].

Now consider a similar pair:
  class C a where
    data G a
  instance C S where
    data G S = Y1 | Y2

The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.

But there is a small complication: in an instance decl, we don't use
qualified names on the LHS; instead we use the class to disambiguate.
Thus:
  module M where
    import Blib( G )
    class C a where
      data G a
    instance C S where
      data G S = Y1 | Y2
Gabor Greif's avatar
Gabor Greif committed
545
Even though there are two G's in scope (M.G and Blib.G), the occurrence
Gabor Greif's avatar
typos  
Gabor Greif committed
546
of 'G' in the 'instance C S' decl is unambiguous, because C has only
547 548 549 550 551
one associated type called G. This is exactly what happens for methods,
and it is only consistent to do the same thing for types. That's the
role of the function lookupTcdName; the (Maybe Name) give the class of
the encloseing instance decl, if any.

552 553 554 555 556 557 558 559 560 561
Note [Looking up Exact RdrNames]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Exact RdrNames are generated by Template Haskell.  See Note [Binders
in Template Haskell] in Convert.

For data types and classes have Exact system Names in the binding
positions for constructors, TyCons etc.  For example
    [d| data T = MkT Int |]
when we splice in and Convert to HsSyn RdrName, we'll get
    data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...
562
These System names are generated by Convert.thRdrName
563 564 565 566

But, constructors and the like need External Names, not System Names!
So we do the following

567
 * In RnEnv.newTopSrcBinder we spot Exact RdrNames that wrap a
568 569 570 571 572
   non-External Name, and make an External name for it. This is
   the name that goes in the GlobalRdrEnv

 * When looking up an occurrence of an Exact name, done in
   RnEnv.lookupExactOcc, we find the Name with the right unique in the
573
   GlobalRdrEnv, and use the one from the envt -- it will be an
574 575 576 577 578
   External Name in the case of the data type/constructor above.

 * Exact names are also use for purely local binders generated
   by TH, such as    \x_33. x_33
   Both binder and occurrence are Exact RdrNames.  The occurrence
Ian Lynagh's avatar
Ian Lynagh committed
579
   gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and
580 581 582 583 584
   misses, because lookupLocalRdrEnv always returns Nothing for
   an Exact Name.  Now we fall through to lookupExactOcc, which
   will find the Name is not in the GlobalRdrEnv, so we just use
   the Exact supplied Name.

585 586 587
Note [Splicing Exact names]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider the splice $(do { x <- newName "x"; return (VarE x) })
Ian Lynagh's avatar
Ian Lynagh committed
588
This will generate a (HsExpr RdrName) term that mentions the
589 590 591 592 593
Exact RdrName "x_56" (or whatever), but does not bind it.  So
when looking such Exact names we want to check that it's in scope,
otherwise the type checker will get confused.  To do this we need to
keep track of all the Names in scope, and the LocalRdrEnv does just that;
we consult it with RdrName.inLocalRdrEnvScope.
594

595
There is another wrinkle.  With TH and -XDataKinds, consider
Ian Lynagh's avatar
Ian Lynagh committed
596
   $( [d| data Nat = Zero
597 598 599 600
          data T = MkT (Proxy 'Zero)  |] )
After splicing, but before renaming we get this:
   data Nat_77{tc} = Zero_78{d}
   data T_79{tc} = MkT_80{d} (Proxy 'Zero_78{tc})  |] )
601
The occurrence of 'Zero in the data type for T has the right unique,
602
but it has a TcClsName name-space in its OccName.  (This is set by
Ian Lynagh's avatar
Ian Lynagh committed
603
the ctxt_ns argument of Convert.thRdrName.)  When we check that is
604 605 606 607
in scope in the GlobalRdrEnv, we need to look up the DataName namespace
too.  (An alternative would be to make the GlobalRdrEnv also have
a Name -> GRE mapping.)

608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
Note [Template Haskell ambiguity]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The GlobalRdrEnv invariant says that if
  occ -> [gre1, ..., gren]
then the gres have distinct Names (INVARIANT 1 of GlobalRdrEnv).
This is guaranteed by extendGlobalRdrEnvRn (the dups check in add_gre).

So how can we get multiple gres in lookupExactOcc_maybe?  Because in
TH we might use the same TH NameU in two different name spaces.
eg (Trac #7241):
   $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
Here we generate a type constructor and data constructor with the same
unique, but differnt name spaces.

It'd be nicer to rule this out in extendGlobalRdrEnvRn, but that would
mean looking up the OccName in every name-space, just in case, and that
seems a bit brutal.  So it's just done here on lookup.  But we might
need to revisit that choice.

simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
627 628 629
Note [Usage for sub-bndrs]
~~~~~~~~~~~~~~~~~~~~~~~~~~
If you have this
Ian Lynagh's avatar
Ian Lynagh committed
630
   import qualified M( C( f ) )
631
   instance M.C T where
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
632 633 634 635 636
     f x = x
then is the qualified import M.f used?  Obviously yes.
But the RdrName used in the instance decl is unqualified.  In effect,
we fill in the qualification by looking for f's whose class is M.C
But when adding to the UsedRdrNames we must make that qualification
637 638 639 640 641 642 643 644 645
explicit (saying "used  M.f"), otherwise we get "Redundant import of M.f".

So we make up a suitable (fake) RdrName.  But be careful
   import qualifed M
   import M( C(f) )
   instance C T where
     f x = x
Here we want to record a use of 'f', not of 'M.f', otherwise
we'll miss the fact that the qualified import is redundant.
646

647
--------------------------------------------------
Ian Lynagh's avatar
Ian Lynagh committed
648
--              Occurrences
649
--------------------------------------------------
Austin Seipp's avatar
Austin Seipp committed
650
-}
651

652 653
getLookupOccRn :: RnM (Name -> Maybe Name)
getLookupOccRn
654 655
  = do local_env <- getLocalRdrEnv
       return (lookupLocalRdrOcc local_env . nameOccName)
656

657 658 659
lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
lookupLocatedOccRn = wrapLocM lookupOccRn

660 661
lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
-- Just look in the local environment
Ian Lynagh's avatar
Ian Lynagh committed
662
lookupLocalOccRn_maybe rdr_name
663 664 665
  = do { local_env <- getLocalRdrEnv
       ; return (lookupLocalRdrEnv local_env rdr_name) }

666
lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))
gmainland's avatar
gmainland committed
667
-- Just look in the local environment
668 669 670
lookupLocalOccThLvl_maybe name
  = do { lcl_env <- getLclEnv
       ; return (lookupNameEnv (tcl_th_bndrs lcl_env) name) }
gmainland's avatar
gmainland committed
671

dreixel's avatar
dreixel committed
672 673
-- lookupOccRn looks up an occurrence of a RdrName
lookupOccRn :: RdrName -> RnM Name
674
lookupOccRn rdr_name
675 676
  = do { mb_name <- lookupOccRn_maybe rdr_name
       ; case mb_name of
677
           Just name -> return name
678
           Nothing   -> reportUnboundName rdr_name }
dreixel's avatar
dreixel committed
679

680 681 682 683 684 685
lookupKindOccRn :: RdrName -> RnM Name
-- Looking up a name occurring in a kind
lookupKindOccRn rdr_name
  = do { mb_name <- lookupOccRn_maybe rdr_name
       ; case mb_name of
           Just name -> return name
686
           Nothing   -> reportUnboundName rdr_name  }
687

dreixel's avatar
dreixel committed
688
-- lookupPromotedOccRn looks up an optionally promoted RdrName.
689
lookupTypeOccRn :: RdrName -> RnM Name
Ian Lynagh's avatar
Ian Lynagh committed
690 691 692
-- see Note [Demotion]
lookupTypeOccRn rdr_name
  = do { mb_name <- lookupOccRn_maybe rdr_name
693 694
       ; case mb_name of {
             Just name -> return name ;
695 696 697 698 699 700 701 702
             Nothing   -> lookup_demoted rdr_name } }

lookup_demoted :: RdrName -> RnM Name
lookup_demoted rdr_name
  | Just demoted_rdr <- demoteRdrName rdr_name
    -- Maybe it's the name of a *data* constructor
  = do { data_kinds <- xoptM Opt_DataKinds
       ; mb_demoted_name <- lookupOccRn_maybe demoted_rdr
703
       ; case mb_demoted_name of
704
           Nothing -> reportUnboundName rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
705
           Just demoted_name
carlostome's avatar
carlostome committed
706 707 708 709
             | data_kinds ->
             do { whenWOptM Opt_WarnUntickedPromotedConstructors $
                  addWarn (untickedPromConstrWarn demoted_name)
                ; return demoted_name }
710
             | otherwise  -> unboundNameX WL_Any rdr_name suggest_dk }
Ian Lynagh's avatar
Ian Lynagh committed
711

712
  | otherwise
713
  = reportUnboundName rdr_name
714

Ian Lynagh's avatar
Ian Lynagh committed
715
  where
716
    suggest_dk = ptext (sLit "A data constructor of that name is in scope; did you mean DataKinds?")
carlostome's avatar
carlostome committed
717 718 719 720 721 722 723
    untickedPromConstrWarn name =
      text "Unticked promoted constructor" <> colon <+> quotes (ppr name) <> dot
      $$
      hsep [ text "Use"
           , quotes (char '\'' <> ppr name)
           , text "instead of"
           , quotes (ppr name) <> dot ]
724

Austin Seipp's avatar
Austin Seipp committed
725
{-
726 727 728 729 730 731 732 733
Note [Demotion]
~~~~~~~~~~~~~~~
When the user writes:
  data Nat = Zero | Succ Nat
  foo :: f Zero -> Int

'Zero' in the type signature of 'foo' is parsed as:
  HsTyVar ("Zero", TcClsName)
dreixel's avatar
dreixel committed
734

Gabor Greif's avatar
Gabor Greif committed
735
When the renamer hits this occurrence of 'Zero' it's going to realise
736 737 738 739 740 741
that it's not in scope. But because it is renaming a type, it knows
that 'Zero' might be a promoted data constructor, so it will demote
its namespace to DataName and do a second lookup.

The final result (after the renamer) will be:
  HsTyVar ("Zero", DataName)
Austin Seipp's avatar
Austin Seipp committed
742
-}
743

744 745 746 747 748 749 750 751 752 753 754 755 756 757 758
--              Use this version to get tracing
--
-- lookupOccRn_maybe, lookupOccRn_maybe' :: RdrName -> RnM (Maybe Name)
-- lookupOccRn_maybe rdr_name
--  = do { mb_res <- lookupOccRn_maybe' rdr_name
--       ; gbl_rdr_env   <- getGlobalRdrEnv
--       ; local_rdr_env <- getLocalRdrEnv
--       ; traceRn $ text "lookupOccRn_maybe" <+>
--           vcat [ ppr rdr_name <+> ppr (getUnique (rdrNameOcc rdr_name))
--                , ppr mb_res
--                , text "Lcl env" <+> ppr local_rdr_env
--                , text "Gbl env" <+> ppr [ (getUnique (nameOccName (gre_name (head gres'))),gres') | gres <- occEnvElts gbl_rdr_env
--                                         , let gres' = filter isLocalGRE gres, not (null gres') ] ]
--       ; return mb_res }

759
lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
760
-- lookupOccRn looks up an occurrence of a RdrName
761
lookupOccRn_maybe rdr_name
762
  = do { local_env <- getLocalRdrEnv
dreixel's avatar
dreixel committed
763 764 765 766
       ; case lookupLocalRdrEnv local_env rdr_name of {
          Just name -> return (Just name) ;
          Nothing   -> do
       { mb_name <- lookupGlobalOccRn_maybe rdr_name
767
       ; case mb_name of {
dreixel's avatar
dreixel committed
768 769
                Just name  -> return (Just name) ;
                Nothing -> do
770 771 772 773 774 775
       { ns <- lookupQualifiedNameGHCi rdr_name
                      -- This test is not expensive,
                      -- and only happens for failed lookups
       ; case ns of
           (n:_) -> return (Just n)  -- Unlikely to be more than one...?
           []    -> return Nothing } } } } }
776 777

lookupGlobalOccRn :: RdrName -> RnM Name
Ian Lynagh's avatar
Ian Lynagh committed
778
-- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
779 780 781 782 783
-- environment.  Adds an error message if the RdrName is not in scope.
lookupGlobalOccRn rdr_name
  = do { mb_name <- lookupGlobalOccRn_maybe rdr_name
       ; case mb_name of
           Just n  -> return n
784 785
           Nothing -> do { traceRn (text "lookupGlobalOccRn" <+> ppr rdr_name)
                         ; unboundName WL_Global rdr_name } }
786

787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
lookupInfoOccRn :: RdrName -> RnM [Name]
-- lookupInfoOccRn is intended for use in GHCi's ":info" command
-- It finds all the GREs that RdrName could mean, not complaining
-- about ambiguity, but rather returning them all
-- C.f. Trac #9881
lookupInfoOccRn rdr_name
  | Just n <- isExact_maybe rdr_name   -- e.g. (->)
  = return [n]

  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
  = do { n <- lookupOrig rdr_mod rdr_occ
       ; return [n] }

  | otherwise
  = do { rdr_env <- getGlobalRdrEnv
       ; let ns = map gre_name (lookupGRE_RdrName rdr_name rdr_env)
       ; qual_ns <- lookupQualifiedNameGHCi rdr_name
       ; return (ns ++ (qual_ns `minusList` ns)) }

806 807 808 809 810
lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
-- No filter function; does not report an error on failure

lookupGlobalOccRn_maybe rdr_name
  | Just n <- isExact_maybe rdr_name   -- This happens in derived code
811
  = do { n' <- lookupExactOcc n; return (Just n') }
812

Simon Marlow's avatar
Simon Marlow committed
813
  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
814 815
  = do { n <- lookupOrig rdr_mod rdr_occ
       ; return (Just n) }
Simon Marlow's avatar
Simon Marlow committed
816 817

  | otherwise
Ian Lynagh's avatar
Ian Lynagh committed
818 819 820 821
  = do  { mb_gre <- lookupGreRn_maybe rdr_name
        ; case mb_gre of
                Nothing  -> return Nothing
                Just gre -> return (Just (gre_name gre)) }
822

823

Adam Gundry's avatar
Adam Gundry committed
824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
-- | Like 'lookupOccRn_maybe', but with a more informative result if
-- the 'RdrName' happens to be a record selector:
--
--   * Nothing         -> name not in scope (no error reported)
--   * Just (Left x)   -> name uniquely refers to x,
--                        or there is a name clash (reported)
--   * Just (Right xs) -> name refers to one or more record selectors;
--                        if overload_ok was False, this list will be
--                        a singleton.
lookupOccRn_overloaded  :: Bool -> RdrName -> RnM (Maybe (Either Name [FieldOcc Name]))
lookupOccRn_overloaded overload_ok rdr_name
  = do { local_env <- getLocalRdrEnv
       ; case lookupLocalRdrEnv local_env rdr_name of {
          Just name -> return (Just (Left name)) ;
          Nothing   -> do
       { mb_name <- lookupGlobalOccRn_overloaded overload_ok rdr_name
       ; case mb_name of {
           Just name -> return (Just name) ;
           Nothing   -> do
       { ns <- lookupQualifiedNameGHCi rdr_name
                      -- This test is not expensive,
                      -- and only happens for failed lookups
       ; case ns of
           (n:_) -> return $ Just $ Left n  -- Unlikely to be more than one...?
           []    -> return Nothing  } } } } }

lookupGlobalOccRn_overloaded :: Bool -> RdrName -> RnM (Maybe (Either Name [FieldOcc Name]))
lookupGlobalOccRn_overloaded overload_ok rdr_name
  | Just n <- isExact_maybe rdr_name   -- This happens in derived code
  = do { n' <- lookupExactOcc n; return (Just (Left n')) }

  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
  = do { n <- lookupOrig rdr_mod rdr_occ
       ; return (Just (Left n)) }

  | otherwise
  = do  { env <- getGlobalRdrEnv
        ; case lookupGRE_RdrName rdr_name env of
                []    -> return Nothing
                [gre] | isRecFldGRE gre
864
                         -> do { addUsedGRE True gre
Adam Gundry's avatar
Adam Gundry committed
865 866 867
                               ; let fld_occ = FieldOcc rdr_name (gre_name gre)
                               ; return (Just (Right [fld_occ])) }
                      | otherwise
868
                         -> do { addUsedGRE True gre
Adam Gundry's avatar
Adam Gundry committed
869 870 871 872 873 874 875 876 877
                               ; return (Just (Left (gre_name gre))) }
                gres  | all isRecFldGRE gres && overload_ok
                            -- Don't record usage for ambiguous selectors
                            -- until we know which is meant
                         -> return (Just (Right (map (FieldOcc rdr_name . gre_name) gres)))
                gres     -> do { addNameClashErrRn rdr_name gres
                               ; return (Just (Left (gre_name (head gres)))) } }


878
--------------------------------------------------
Ian Lynagh's avatar
Ian Lynagh committed
879
--      Lookup in the Global RdrEnv of the module
880 881
--------------------------------------------------

882
lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
883 884 885 886 887 888
-- Look up the RdrName in the GlobalRdrEnv
--   Exactly one binding: records it as "used", return (Just gre)
--   No bindings:         return Nothing
--   Many bindings:       report "ambiguous", return an arbitrary (Just gre)
-- (This API is a bit strange; lookupGRERn2_maybe is simpler.
--  But it works and I don't want to fiddle too much.)
Ian Lynagh's avatar
Ian Lynagh committed
889 890
lookupGreRn_maybe rdr_name
  = do  { env <- getGlobalRdrEnv
891
        ; case lookupGRE_RdrName rdr_name env of
Ian Lynagh's avatar
Ian Lynagh committed
892
            []    -> return Nothing
893
            [gre] -> do { addUsedGRE True gre
894
                        ; return (Just gre) }
Ian Lynagh's avatar
Ian Lynagh committed
895
            gres  -> do { addNameClashErrRn rdr_name gres
896
                        ; traceRn (text "name clash" <+> (ppr rdr_name $$ ppr gres $$ ppr env))
Ian Lynagh's avatar
Ian Lynagh committed
897
                        ; return (Just (head gres)) } }
898

899 900 901 902 903 904 905 906 907 908
lookupGreRn2_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
-- Look up the RdrName in the GlobalRdrEnv
--   Exactly one binding: record it as "used",   return (Just gre)
--   No bindings:         report "not in scope", return Nothing
--   Many bindings:       report "ambiguous",    return Nothing
lookupGreRn2_maybe rdr_name
  = do  { env <- getGlobalRdrEnv
        ; case lookupGRE_RdrName rdr_name env of
            []    -> do { _ <- unboundName WL_Global rdr_name
                        ; return Nothing }
909
            [gre] -> do { addUsedGRE True gre
910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926
                        ; return (Just gre) }
            gres  -> do { addNameClashErrRn rdr_name gres
                        ; traceRn (text "name clash" <+> (ppr rdr_name $$ ppr gres $$ ppr env))
                        ; return Nothing } }

lookupGreAvailRn :: RdrName -> RnM (Name, AvailInfo)
-- Used in export lists
-- If not found or ambiguous, add error message, and fake with UnboundName
lookupGreAvailRn rdr_name
  = do  { mb_gre <- lookupGreRn2_maybe rdr_name
        ; case mb_gre of {
            Just gre -> return (gre_name gre, availFromGRE gre) ;
            Nothing  ->
    do  { traceRn (text "lookupGreRn" <+> ppr rdr_name)
        ; let name = mkUnboundName rdr_name
        ; return (name, Avail name) } } }

Austin Seipp's avatar
Austin Seipp committed
927 928 929
{-
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
930
                Deprecations
Austin Seipp's avatar
Austin Seipp committed
931 932
*                                                      *
*********************************************************
933

934 935 936 937 938
Note [Handling of deprecations]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* We report deprecations at each *occurrence* of the deprecated thing
  (see Trac #5867)

Simon Peyton Jones's avatar
Simon Peyton Jones committed
939
* We do not report deprecations for locally-defined names. For a
940 941 942 943 944
  start, we may be exporting a deprecated thing. Also we may use a
  deprecated thing in the defn of another deprecated things.  We may
  even use a deprecated thing in the defn of a non-deprecated thing,
  when changing a module's interface.

945
* addUsedGREs: we do not report deprecations for sub-binders:
946 947 948
     - the ".." completion for records
     - the ".." in an export item 'T(..)'
     - the things exported by a module export 'module M'
Austin Seipp's avatar
Austin Seipp committed
949
-}
950

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
addUsedDataCons :: GlobalRdrEnv -> TyCon -> RnM ()
-- Remember use of in-scope data constructors (Trac #7969)
addUsedDataCons rdr_env tycon
  = addUsedGREs [ gre
                | dc <- tyConDataCons tycon
                , gre : _ <- [lookupGRE_Name rdr_env (dataConName dc) ] ]

addUsedGRE :: Bool -> GlobalRdrElt -> RnM ()
-- Called for both local and imported things
-- Add usage *and* warn if deprecated
addUsedGRE warn_if_deprec gre
  = do { when warn_if_deprec (warnIfDeprecated gre)
       ; unless (isLocalGRE gre) $
         do { env <- getGblEnv
            ; traceRn (text "addUsedGRE" <+> ppr gre)
            ; updMutVar (tcg_used_gres env) (gre :) } }

addUsedGREs :: [GlobalRdrElt] -> RnM ()
-- Record uses of any *imported* GREs
-- Used for recording used sub-bndrs
971
-- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]
972 973 974 975 976 977 978
addUsedGREs gres
  | null imp_gres = return ()
  | otherwise     = do { env <- getGblEnv
                       ; traceRn (text "addUsedGREs" <+> ppr imp_gres)
                       ; updMutVar (tcg_used_gres env) (imp_gres ++) }
  where
    imp_gres = filterOut isLocalGRE gres
979

980
warnIfDeprecated :: GlobalRdrElt -> RnM ()
981 982
warnIfDeprecated gre@(GRE { gre_name = name, gre_imp = iss })
  | (imp_spec : _) <- iss
983
  = do { dflags <- getDynFlags
984 985 986 987
       ; this_mod <- getModule
       ; when (wopt Opt_WarnWarningsDeprecations dflags &&
               not (nameIsLocalOrFrom this_mod name)) $
                   -- See Note [Handling of deprecations]
988 989
         do { iface <- loadInterfaceForName doc name
            ; case lookupImpDeprec iface gre of
990
                Just txt -> addWarn (mk_msg imp_spec txt)
991
                Nothing  -> return () } }
992 993
  | otherwise
  = return ()
994
  where
Adam Gundry's avatar
Adam Gundry committed
995
    occ = greOccName gre
996
    name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
Adam Gundry's avatar
Adam Gundry committed
997
    doc = ptext (sLit "The name") <+> quotes (ppr occ) <+> ptext (sLit "is mentioned explicitly")
998

999 1000
    mk_msg imp_spec txt
      = sep [ sep [ ptext (sLit "In the use of")
Adam Gundry's avatar
Adam Gundry committed
1001 1002
                    <+> pprNonVarNameSpace (occNameSpace occ)
                    <+> quotes (ppr occ)
1003 1004 1005 1006 1007 1008 1009
                  , parens imp_msg <> colon ]
            , ppr txt ]
      where
        imp_mod  = importSpecModule imp_spec
        imp_msg  = ptext (sLit "imported from") <+> ppr imp_mod <> extra
        extra | imp_mod == moduleName name_mod = Outputable.empty
              | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod
1010 1011 1012 1013

lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
lookupImpDeprec iface gre
  = mi_warn_fn iface (gre_name gre) `mplus`  -- Bleat if the thing,
1014
    case gre_par gre of                      -- or its parent, is warn'd
Adam Gundry's avatar
Adam Gundry committed
1015 1016 1017
       ParentIs  p              -> mi_warn_fn iface p
       FldParent { par_is = p } -> mi_warn_fn iface p
       NoParent                 -> Nothing
1018