RnEnv.hs 78.4 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,
17
        reportUnboundName,
18

Ian Lynagh's avatar
Ian Lynagh committed
19
        HsSigCtxt(..), lookupLocalTcNames, lookupSigOccRn,
20

Ian Lynagh's avatar
Ian Lynagh committed
21 22
        lookupFixityRn, lookupTyFixityRn,
        lookupInstDeclBndr, lookupSubBndrOcc, lookupFamInstName,
23
        greRdrName,
24
        lookupSubBndrGREs, lookupConstructorFields,
25
        lookupSyntaxName, lookupSyntaxNames, lookupIfThenElse,
26
        lookupGreRn, lookupGreRn_maybe,
Austin Seipp's avatar
Austin Seipp committed
27
        lookupGreLocalRn_maybe,
Ian Lynagh's avatar
Ian Lynagh committed
28 29 30
        getLookupOccRn, addUsedRdrNames,

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

        checkDupRdrNames, checkShadowedRdrNames,
38
        checkDupNames, checkDupAndShadowedNames, checkTupSize,
Ian Lynagh's avatar
Ian Lynagh committed
39 40 41
        addFvRn, mapFvRn, mapMaybeFvRn, mapFvRnCPS,
        warnUnusedMatches,
        warnUnusedTopBinds, warnUnusedLocalBinds,
42
        dataTcOccs, kindSigErr, perhapsForallMsg,
43
        HsDocContext(..), docOfHsDocContext
44
    ) where
45

46
#include "HsVersions.h"
47

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

Austin Seipp's avatar
Austin Seipp committed
81 82 83
{-
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
84
                Source-code binders
Austin Seipp's avatar
Austin Seipp committed
85 86
*                                                      *
*********************************************************
87

88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
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
require adjusting addUsedRdrName so that during signature compilation,
we do not report deprecation warnings for LocalDef.  See also
Note [Handling of deprecations]
Austin Seipp's avatar
Austin Seipp committed
145
-}
146

147 148
newTopSrcBinder :: Located RdrName -> RnM Name
newTopSrcBinder (L loc rdr_name)
149
  | Just name <- isExact_maybe rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
150 151 152 153 154 155 156 157 158
  =     -- 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
159 160 161
    if isExternalName name then
      do { this_mod <- getModule
         ; unless (this_mod == nameModule name)
Ian Lynagh's avatar
Ian Lynagh committed
162
                  (addErrAt loc (badOrigBinding rdr_name))
163 164 165
         ; return name }
    else   -- See Note [Binders in Template Haskell] in Convert.hs
      do { let occ = nameOccName name
Ian Lynagh's avatar
Ian Lynagh committed
166
         ; occ `seq` return ()  -- c.f. seq in newGlobalBinder
167 168 169 170 171
         ; this_mod <- getModule
         ; updNameCache $ \ ns ->
           let name' = mkExternalName (nameUnique name) this_mod occ loc
               ns'   = ns { nsNames = extendNameCache (nsNames ns) this_mod occ name' }
           in (ns', name') }
172

Simon Marlow's avatar
Simon Marlow committed
173
  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
174
  = do  { this_mod <- getModule
175
        ; unless (rdr_mod == this_mod || rdr_mod == rOOT_MAIN)
Ian Lynagh's avatar
Ian Lynagh committed
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194
                 (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 }
195 196

  | otherwise
Ian Lynagh's avatar
Ian Lynagh committed
197 198 199 200 201 202
  = 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
203
        ; env <- getGblEnv
Ian Lynagh's avatar
Ian Lynagh committed
204 205 206 207 208
        ; 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) }
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
          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:
                      --    addUsedRdrName True gre rdr_name
                      -- 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
233
                -- Normal case
234 235
             do { this_mod <- getModule
                ; newGlobalBinder this_mod (rdrNameOcc rdr_name) loc } }
236

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

Looking up a name in the RnEnv.

246 247 248 249 250 251 252 253 254 255 256
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
257
-}
258

259 260
lookupTopBndrRn :: RdrName -> RnM Name
lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
Ian Lynagh's avatar
Ian Lynagh committed
261
                       case nopt of
262 263
                         Just n' -> return n'
                         Nothing -> do traceRn $ text "lookupTopBndrRn"
264
                                       unboundName WL_LocalTop n
265

266 267 268
lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn = wrapLocM lookupTopBndrRn

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

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

Ian Lynagh's avatar
Ian Lynagh committed
290 291 292 293 294 295
  | 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
296
        ; return (Just n)}
297 298

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

306
        ; mb_gre <- lookupGreLocalRn_maybe rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
307 308 309
        ; case mb_gre of
                Nothing  -> return Nothing
                Just gre -> return (Just $ gre_name gre) }
310

311

312
-----------------------------------------------
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
313 314
-- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].
-- This adds an error if the name cannot be found.
315 316
lookupExactOcc :: Name -> RnM Name
lookupExactOcc name
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
317 318 319 320 321 322 323 324 325 326 327
  = 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
328 329
  | Just thing <- wiredInNameTyThing_maybe name
  , Just tycon <- case thing of
cactus's avatar
cactus committed
330 331 332
                    ATyCon tc                 -> Just tc
                    AConLike (RealDataCon dc) -> Just (dataConTyCon dc)
                    _                         -> Nothing
333 334
  , isTupleTyCon tycon
  = do { checkTupSize (tyConArity tycon)
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
335
       ; return (Right name) }
336

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

Ian Lynagh's avatar
Ian Lynagh committed
340
  | otherwise
341
  = do { env <- getGlobalRdrEnv
Ian Lynagh's avatar
Ian Lynagh committed
342
       ; let -- See Note [Splicing Exact names]
343 344 345 346 347 348
             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
349
                          , gre_name gre == name ]
350
       ; case gres of
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 */
                       }
Ian Lynagh's avatar
Ian Lynagh committed
367

eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
368 369
           [gre]   -> return (Right (gre_name gre))
           _       -> return (Left dup_nm_err)
Austin Seipp's avatar
Austin Seipp committed
370
           -- We can get more than one GRE here, if there are multiple
Gabor Greif's avatar
Gabor Greif committed
371 372
           -- bindings for the same name. Sometimes they are caught later
           -- by findLocalDupsRdrEnv, like in this example (Trac #8932):
373 374
           --    $( [d| foo :: a->a; foo x = x |])
           --    foo = True
Gabor Greif's avatar
Gabor Greif committed
375
           -- But when the names are totally identical, we panic (Trac #7241):
376
           --    $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
Gabor Greif's avatar
Gabor Greif committed
377
           -- So, let's emit an error here, even if it will lead to duplication in some cases.
378
       }
379

380 381
  where
    exact_nm_err = hang (ptext (sLit "The exact Name") <+> quotes (ppr name) <+> ptext (sLit "is not in scope"))
382 383
                      2 (vcat [ ptext (sLit "Probable cause: you used a unique Template Haskell name (NameU), ")
                              , ptext (sLit "perhaps via newName, but did not bind it")
384
                              , ptext (sLit "If that's it, then -ddump-splices might be useful") ])
385 386 387 388
    dup_nm_err   = hang (ptext (sLit "Duplicate exact Name") <+> quotes (ppr $ nameOccName name))
                      2 (vcat [ ptext (sLit "Probable cause: you used a unique Template Haskell name (NameU), ")
                              , ptext (sLit "perhaps via newName, but bound it multiple times")
                              , ptext (sLit "If that's it, then -ddump-splices might be useful") ])
389

390
-----------------------------------------------
391
lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
Ian Lynagh's avatar
Ian Lynagh committed
392
-- This is called on the method name on the left-hand side of an
393 394 395 396 397
-- 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.
398
--
Ian Lynagh's avatar
Ian Lynagh committed
399
-- Furthermore, note that we take no account of whether the
400 401 402
-- 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
403 404 405 406
--
-- The "what" parameter says "method" or "associated type",
-- depending on what we are looking up
lookupInstDeclBndr cls what rdr
407
  = do { when (isQual rdr)
Ian Lynagh's avatar
Ian Lynagh committed
408 409 410 411
              (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.)
412 413 414 415 416
       ; lookupSubBndrOcc False -- False => we don't give deprecated
                                -- warnings when a deprecated class
                                -- method is defined. We only warn
                                -- when it's used
                          (ParentIs cls) doc rdr }
417
  where
418
    doc = what <+> ptext (sLit "of class") <+> quotes (ppr cls)
419

420 421

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

430 431 432
-----------------------------------------------
lookupConstructorFields :: Name -> RnM [Name]
-- Look up the fields of a given constructor
Ian Lynagh's avatar
Ian Lynagh committed
433 434 435 436 437 438 439
--   *  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
440 441

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

-----------------------------------------------
451 452 453 454
-- 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
455
--
456
-- NB: Consider this:
Ian Lynagh's avatar
Ian Lynagh committed
457 458
--      module Foo where { data R = R { fld :: Int } }
--      module Odd where { import Foo; fld x = x { fld = 3 } }
459 460 461 462
-- 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.

463 464
lookupSubBndrOcc :: Bool
                 -> Parent  -- NoParent   => just look it up as usual
Ian Lynagh's avatar
Ian Lynagh committed
465 466
                            -- ParentIs p => use p to disambiguate
                 -> SDoc -> RdrName
467
                 -> RnM Name
468
lookupSubBndrOcc warnIfDeprec parent doc rdr_name
469
  | Just n <- isExact_maybe rdr_name   -- This happens in derived code
470
  = lookupExactOcc n
471 472 473 474

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

Ian Lynagh's avatar
Ian Lynagh committed
475 476 477 478 479 480 481
  | 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
482
            [gre] -> do { addUsedRdrName warnIfDeprec gre (used_rdr_name gre)
483
                          -- Add a usage; this is an *occurrence* site
484
                        ; return (gre_name gre) }
Ian Lynagh's avatar
Ian Lynagh committed
485 486 487 488
            []    -> do { addErr (unknownSubordinateErr doc rdr_name)
                        ; return (mkUnboundName rdr_name) }
            gres  -> do { addNameClashErrRn rdr_name gres
                        ; return (gre_name (head gres)) } }
489
  where
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
490
    -- Note [Usage for sub-bndrs]
491 492
    used_rdr_name gre
      | isQual rdr_name = rdr_name
493 494 495 496 497 498 499 500
      | otherwise       = greRdrName gre

greRdrName :: GlobalRdrElt -> RdrName
greRdrName gre
  = case gre_prov gre of
      LocalDef    -> unqual_rdr
      Imported is -> used_rdr_name_from_is is

Ian Lynagh's avatar
Ian Lynagh committed
501
  where
502 503
    occ = nameOccName (gre_name gre)
    unqual_rdr = mkRdrUnqual occ
504

Ian Lynagh's avatar
Ian Lynagh committed
505 506
    used_rdr_name_from_is imp_specs     -- rdr_name is unqualified
      | not (all (is_qual . is_decl) imp_specs)
507
      = unqual_rdr  -- An unqualified import is available
508
      | otherwise
Ian Lynagh's avatar
Ian Lynagh committed
509 510
      =             -- Only qualified imports available, so make up
                    -- a suitable qualifed name from the first imp_spec
511
        ASSERT( not (null imp_specs) )
512
        mkRdrQual (is_as (is_decl (head imp_specs))) occ
513 514 515 516 517 518 519 520 521 522

lookupSubBndrGREs :: GlobalRdrEnv -> Parent -> RdrName -> [GlobalRdrElt]
-- If Parent = NoParent, just do a normal lookup
-- If Parent = Parent p then find all GREs that
--   (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
      NoParent   -> pickGREs rdr_name gres
Ian Lynagh's avatar
Ian Lynagh committed
523
      ParentIs p
524 525 526 527 528 529 530 531
        | isUnqual rdr_name -> filter (parent_is p) gres
        | otherwise         -> filter (parent_is p) (pickGREs rdr_name gres)

  where
    gres = lookupGlobalRdrEnv env (rdrNameOcc rdr_name)

    parent_is p (GRE { gre_par = ParentIs p' }) = p == p'
    parent_is _ _                               = False
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
532

Austin Seipp's avatar
Austin Seipp committed
533
{-
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
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
561
Even though there are two G's in scope (M.G and Blib.G), the occurrence
Gabor Greif's avatar
typos  
Gabor Greif committed
562
of 'G' in the 'instance C S' decl is unambiguous, because C has only
563 564 565 566 567
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.

568 569 570 571 572 573 574 575 576 577
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")) ...
578
These System names are generated by Convert.thRdrName
579 580 581 582 583 584 585 586 587 588

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

 * In RnEnv.newGlobalBinder we spot Exact RdrNames that wrap a
   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
589
   GlobalRdrEnv, and use the one from the envt -- it will be an
590 591 592 593 594
   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
595
   gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and
596 597 598 599 600
   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.

601 602 603
Note [Splicing Exact names]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider the splice $(do { x <- newName "x"; return (VarE x) })
Ian Lynagh's avatar
Ian Lynagh committed
604
This will generate a (HsExpr RdrName) term that mentions the
605 606 607 608 609
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.
610

611
There is another wrinkle.  With TH and -XDataKinds, consider
Ian Lynagh's avatar
Ian Lynagh committed
612
   $( [d| data Nat = Zero
613 614 615 616
          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})  |] )
617
The occurrence of 'Zero in the data type for T has the right unique,
618
but it has a TcClsName name-space in its OccName.  (This is set by
Ian Lynagh's avatar
Ian Lynagh committed
619
the ctxt_ns argument of Convert.thRdrName.)  When we check that is
620 621 622 623
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.)

simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
624 625 626
Note [Usage for sub-bndrs]
~~~~~~~~~~~~~~~~~~~~~~~~~~
If you have this
Ian Lynagh's avatar
Ian Lynagh committed
627
   import qualified M( C( f ) )
628
   instance M.C T where
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
629 630 631 632 633
     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
634 635 636 637 638 639 640 641 642
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.
643

644
--------------------------------------------------
Ian Lynagh's avatar
Ian Lynagh committed
645
--              Occurrences
646
--------------------------------------------------
Austin Seipp's avatar
Austin Seipp committed
647
-}
648

649 650
getLookupOccRn :: RnM (Name -> Maybe Name)
getLookupOccRn
651 652
  = do local_env <- getLocalRdrEnv
       return (lookupLocalRdrOcc local_env . nameOccName)
653

654 655 656
lookupLocatedOccRn :: Located RdrName -> RnM (Located Name)
lookupLocatedOccRn = wrapLocM lookupOccRn

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

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

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

677 678 679 680 681 682
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
683
           Nothing   -> reportUnboundName rdr_name  }
684

dreixel's avatar
dreixel committed
685
-- lookupPromotedOccRn looks up an optionally promoted RdrName.
686
lookupTypeOccRn :: RdrName -> RnM Name
Ian Lynagh's avatar
Ian Lynagh committed
687 688 689
-- see Note [Demotion]
lookupTypeOccRn rdr_name
  = do { mb_name <- lookupOccRn_maybe rdr_name
690 691
       ; case mb_name of {
             Just name -> return name ;
692 693 694 695 696 697 698 699
             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
700
       ; case mb_demoted_name of
701
           Nothing -> reportUnboundName rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
702
           Just demoted_name
carlostome's avatar
carlostome committed
703 704 705 706
             | data_kinds ->
             do { whenWOptM Opt_WarnUntickedPromotedConstructors $
                  addWarn (untickedPromConstrWarn demoted_name)
                ; return demoted_name }
707
             | otherwise  -> unboundNameX WL_Any rdr_name suggest_dk }
Ian Lynagh's avatar
Ian Lynagh committed
708

709
  | otherwise
710
  = reportUnboundName rdr_name
711

Ian Lynagh's avatar
Ian Lynagh committed
712
  where
713
    suggest_dk = ptext (sLit "A data constructor of that name is in scope; did you mean DataKinds?")
carlostome's avatar
carlostome committed
714 715 716 717 718 719 720
    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 ]
721

Austin Seipp's avatar
Austin Seipp committed
722
{-
723 724 725 726 727 728 729 730
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
731

Gabor Greif's avatar
Gabor Greif committed
732
When the renamer hits this occurrence of 'Zero' it's going to realise
733 734 735 736 737 738
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
739
-}
740

741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
--              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 }

756
lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
757
-- lookupOccRn looks up an occurrence of a RdrName
758
lookupOccRn_maybe rdr_name
759
  = do { local_env <- getLocalRdrEnv
dreixel's avatar
dreixel committed
760 761 762 763
       ; case lookupLocalRdrEnv local_env rdr_name of {
          Just name -> return (Just name) ;
          Nothing   -> do
       { mb_name <- lookupGlobalOccRn_maybe rdr_name
764
       ; case mb_name of {
dreixel's avatar
dreixel committed
765 766
                Just name  -> return (Just name) ;
                Nothing -> do
767 768 769 770 771 772
       { 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 } } } } }
773 774

lookupGlobalOccRn :: RdrName -> RnM Name
Ian Lynagh's avatar
Ian Lynagh committed
775
-- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
776 777 778 779 780
-- 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
781 782
           Nothing -> do { traceRn (text "lookupGlobalOccRn" <+> ppr rdr_name)
                         ; unboundName WL_Global rdr_name } }
783

784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802
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)) }

803 804 805 806 807
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
808
  = do { n' <- lookupExactOcc n; return (Just n') }
809

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

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

820 821

--------------------------------------------------
Ian Lynagh's avatar
Ian Lynagh committed
822
--      Lookup in the Global RdrEnv of the module
823 824
--------------------------------------------------

825
lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
826
-- Just look up the RdrName in the GlobalRdrEnv
Ian Lynagh's avatar
Ian Lynagh committed
827
lookupGreRn_maybe rdr_name
828
  = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
829

830 831
lookupGreRn :: RdrName -> RnM GlobalRdrElt
-- If not found, add error message, and return a fake GRE
Ian Lynagh's avatar
Ian Lynagh committed
832 833 834 835 836 837
lookupGreRn rdr_name
  = do  { mb_gre <- lookupGreRn_maybe rdr_name
        ; case mb_gre of {
            Just gre -> return gre ;
            Nothing  -> do
        { traceRn (text "lookupGreRn" <+> ppr rdr_name)
838
        ; name <- unboundName WL_Global rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
839 840
        ; return (GRE { gre_name = name, gre_par = NoParent,
                        gre_prov = LocalDef }) }}}
841

842
lookupGreLocalRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
843
-- Similar, but restricted to locally-defined things
844
lookupGreLocalRn_maybe rdr_name
845 846 847 848
  = lookupGreRn_help rdr_name lookup_fn
  where
    lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)

Ian Lynagh's avatar
Ian Lynagh committed
849 850 851
lookupGreRn_help :: RdrName                     -- Only used in error message
                 -> (GlobalRdrEnv -> [GlobalRdrElt])    -- Lookup function
                 -> RnM (Maybe GlobalRdrElt)
852 853
-- Checks for exactly one match; reports deprecations
-- Returns Nothing, without error, if too few
Ian Lynagh's avatar
Ian Lynagh committed
854 855 856 857
lookupGreRn_help rdr_name lookup
  = do  { env <- getGlobalRdrEnv
        ; case lookup env of
            []    -> return Nothing
858
            [gre] -> do { addUsedRdrName True gre rdr_name
859
                        ; return (Just gre) }
Ian Lynagh's avatar
Ian Lynagh committed
860 861
            gres  -> do { addNameClashErrRn rdr_name gres
                        ; return (Just (head gres)) } }
862

Austin Seipp's avatar
Austin Seipp committed
863 864 865
{-
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
866
                Deprecations
Austin Seipp's avatar
Austin Seipp committed
867 868
*                                                      *
*********************************************************
869

870 871 872 873 874 875 876 877 878 879 880 881 882 883 884
Note [Handling of deprecations]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* We report deprecations at each *occurrence* of the deprecated thing
  (see Trac #5867)

* We do not report deprectations for locally-definded names. For a
  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.

* addUsedRdrNames: we do not report deprecations for sub-binders:
     - 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
885
-}
886

887
addUsedRdrName :: Bool -> GlobalRdrElt -> RdrName -> RnM ()
888
-- Record usage of imported RdrNames
889
addUsedRdrName warnIfDeprec gre rdr
890 891
  | isLocalGRE gre = return ()  -- No call to warnIfDeprecated
                                -- See Note [Handling of deprecations]
892
  | otherwise      = do { env <- getGblEnv
893
                        ; when warnIfDeprec $ warnIfDeprecated gre
894
                        ; updMutVar (tcg_used_rdrnames env)
Ian Lynagh's avatar
Ian Lynagh committed
895
                                    (\s -> Set.insert rdr s) }
896 897 898 899 900

addUsedRdrNames :: [RdrName] -> RnM ()
-- Record used sub-binders
-- We don't check for imported-ness here, because it's inconvenient
-- and not stritly necessary.
901
-- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]
902 903 904
addUsedRdrNames rdrs
  = do { env <- getGblEnv
       ; updMutVar (tcg_used_rdrnames env)
Ian Lynagh's avatar
Ian Lynagh committed
905
                   (\s -> foldr Set.insert s rdrs) }
906

907 908 909 910 911 912
warnIfDeprecated :: GlobalRdrElt -> RnM ()
warnIfDeprecated gre@(GRE { gre_name = name, gre_prov = Imported (imp_spec : _) })
  = do { dflags <- getDynFlags
       ; when (wopt Opt_WarnWarningsDeprecations dflags) $
         do { iface <- loadInterfaceForName doc name
            ; case lookupImpDeprec iface gre of
Ian Lynagh's avatar
Ian Lynagh committed
913
                Just txt -> addWarn (mk_msg txt)
914 915 916 917 918 919 920 921 922 923 924
                Nothing  -> return () } }
  where
    mk_msg txt = sep [ sep [ ptext (sLit "In the use of")
                             <+> pprNonVarNameSpace (occNameSpace (nameOccName name))
                             <+> quotes (ppr name)
                           , parens imp_msg <> colon ]
                     , ppr txt ]

    name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
    imp_mod  = importSpecModule imp_spec
    imp_msg  = ptext (sLit "imported from") <+> ppr imp_mod <> extra
925
    extra | imp_mod == moduleName name_mod = Outputable.empty
926 927 928 929 930 931 932 933 934
          | otherwise = ptext (sLit ", but defined in") <+> ppr name_mod

    doc = ptext (sLit "The name") <+> quotes (ppr name) <+> ptext (sLit "is mentioned explicitly")

warnIfDeprecated _ = return ()   -- No deprecations for things defined locally

lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
lookupImpDeprec iface gre
  = mi_warn_fn iface (gre_name gre) `mplus`  -- Bleat if the thing,
935
    case gre_par gre of                      -- or its parent, is warn'd
Ian Lynagh's avatar
Ian Lynagh committed
936
       ParentIs p -> mi_warn_fn iface p
937
       NoParent   -> Nothing
938

Austin Seipp's avatar
Austin Seipp committed
939
{-
940 941
Note [Used names with interface not loaded]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
942
It's (just) possible to find a used
943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959
Name whose interface hasn't been loaded:

a) It might be a WiredInName; in that case we may not load
   its interface (although we could).

b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
   These are seen as "used" by the renamer (if -XRebindableSyntax)
   is on), but the typechecker may discard their uses
   if in fact the in-scope fromRational is GHC.Read.fromRational,
   (see tcPat.tcOverloadedLit), and the typechecker sees that the type
   is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
   In that obscure case it won't force the interface in.

In both cases we simply don't permit deprecations;
this is, after all, wired-in stuff.


Austin Seipp's avatar
Austin Seipp committed
960 961
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
962
                GHCi support
Austin Seipp's avatar
Austin Seipp committed
963 964
*                                                      *
*********************************************************
965

966 967 968 969 970 971
A qualified name on the command line can refer to any module at
all: we try to load the interface if we don't already have it, just
as if there was an "import qualified M" declaration for every
module.

If we fail we just return Nothing, rather than bleating
972
about "attempting to use module ‘D’ (./D.hs) which is not loaded"
973 974 975 976 977 978 979
which is what loadSrcInterface does.

Note [Safe Haskell and GHCi]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We DONT do this Safe Haskell as we need to check imports. We can
and should instead check the qualified import but at the moment
this requires some refactoring so leave as a TODO
Austin Seipp's avatar
Austin Seipp committed
980
-}
981

982 983
lookupQualifiedNameGHCi :: RdrName -> RnM [Name]
lookupQualifiedNameGHCi rdr_name
984 985
  = -- We want to behave as we would for a source file import here,
    -- and respect hiddenness of modules/packages, hence loadSrcInterface.
986 987 988
    do { dflags  <- getDynFlags
       ; is_ghci <- getIsGHCi
       ; go_for_it dflags is_ghci }
Simon Marlow's avatar
Simon Marlow committed
989