RnEnv.hs 77.5 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,
Ian Lynagh's avatar
Ian Lynagh committed
13
        lookupLocalOccRn_maybe,
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
Ian Lynagh's avatar
Ian Lynagh committed
78
import Constants        ( mAX_TUPLE_SIZE )
Ian Lynagh's avatar
Ian Lynagh committed
79

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

87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143
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
144
-}
145

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

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

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

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

Looking up a name in the RnEnv.

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

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

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

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

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

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

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

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

310

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

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

Ian Lynagh's avatar
Ian Lynagh committed
339
  | otherwise
340
  = do { env <- getGlobalRdrEnv
Ian Lynagh's avatar
Ian Lynagh committed
341
       ; let -- See Note [Splicing Exact names]
342 343 344 345 346 347
             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
348
                          , gre_name gre == name ]
349
       ; case gres of
350 351
           []    -> -- See Note [Splicing Exact names]
                    do { lcl_env <- getLocalRdrEnv
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
352 353 354
                       ; if name `inLocalRdrEnvScope` lcl_env
                         then return (Right name)
                         else
355 356 357
#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
358 359 360
                            ; if name `elemNameSet` th_topnames
                              then return (Right name)
                              else return (Left exact_nm_err)
361 362
                            }
#else /* !GHCI */
eir@cis.upenn.edu's avatar
eir@cis.upenn.edu committed
363
                         return (Left exact_nm_err)
364 365
#endif /* !GHCI */
                       }
Ian Lynagh's avatar
Ian Lynagh committed
366

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

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

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

419 420

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

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

lookupConstructorFields con_name
Ian Lynagh's avatar
Ian Lynagh committed
441 442 443 444 445 446 447
  = 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) } }
448 449

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

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

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

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

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

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
522
      ParentIs p
523 524 525 526 527 528 529 530
        | 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
531

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

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

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
588
   GlobalRdrEnv, and use the one from the envt -- it will be an
589 590 591 592 593
   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
594
   gets looked up in the LocalRdrEnv by RnEnv.lookupOccRn, and
595 596 597 598 599
   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.

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

610
There is another wrinkle.  With TH and -XDataKinds, consider
Ian Lynagh's avatar
Ian Lynagh committed
611
   $( [d| data Nat = Zero
612 613 614 615
          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})  |] )
616
The occurrence of 'Zero in the data type for T has the right unique,
617
but it has a TcClsName name-space in its OccName.  (This is set by
Ian Lynagh's avatar
Ian Lynagh committed
618
the ctxt_ns argument of Convert.thRdrName.)  When we check that is
619 620 621 622
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
623 624 625
Note [Usage for sub-bndrs]
~~~~~~~~~~~~~~~~~~~~~~~~~~
If you have this
Ian Lynagh's avatar
Ian Lynagh committed
626
   import qualified M( C( f ) )
627
   instance M.C T where
simonpj@microsoft.com's avatar
simonpj@microsoft.com committed
628 629 630 631 632
     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
633 634 635 636 637 638 639 640 641
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.
642

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

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

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

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

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

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

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

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

708
  | otherwise
709
  = reportUnboundName rdr_name
710

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

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

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

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

755
lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
756
-- lookupOccRn looks up an occurrence of a RdrName
757
lookupOccRn_maybe rdr_name
758
  = do { local_env <- getLocalRdrEnv
dreixel's avatar
dreixel committed
759 760 761 762
       ; case lookupLocalRdrEnv local_env rdr_name of {
          Just name -> return (Just name) ;
          Nothing   -> do
       { mb_name <- lookupGlobalOccRn_maybe rdr_name
763
       ; case mb_name of {
dreixel's avatar
dreixel committed
764 765
                Just name  -> return (Just name) ;
                Nothing -> do
766 767 768 769
       { dflags  <- getDynFlags
       ; is_ghci <- getIsGHCi   -- This test is not expensive,
                                -- and only happens for failed lookups
       ; lookupQualifiedNameGHCi dflags is_ghci rdr_name } } } } }
770 771

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

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
786
  = do { n' <- lookupExactOcc n; return (Just n') }
787

Simon Marlow's avatar
Simon Marlow committed
788
  | Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
789 790
  = do { n <- lookupOrig rdr_mod rdr_occ
       ; return (Just n) }
Simon Marlow's avatar
Simon Marlow committed
791 792

  | otherwise
Ian Lynagh's avatar
Ian Lynagh committed
793 794 795 796
  = do  { mb_gre <- lookupGreRn_maybe rdr_name
        ; case mb_gre of
                Nothing  -> return Nothing
                Just gre -> return (Just (gre_name gre)) }
797

798 799

--------------------------------------------------
Ian Lynagh's avatar
Ian Lynagh committed
800
--      Lookup in the Global RdrEnv of the module
801 802
--------------------------------------------------

803
lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
804
-- Just look up the RdrName in the GlobalRdrEnv
Ian Lynagh's avatar
Ian Lynagh committed
805
lookupGreRn_maybe rdr_name
806
  = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
807

808 809
lookupGreRn :: RdrName -> RnM GlobalRdrElt
-- If not found, add error message, and return a fake GRE
Ian Lynagh's avatar
Ian Lynagh committed
810 811 812 813 814 815
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)
816
        ; name <- unboundName WL_Global rdr_name
Ian Lynagh's avatar
Ian Lynagh committed
817 818
        ; return (GRE { gre_name = name, gre_par = NoParent,
                        gre_prov = LocalDef }) }}}
819

820
lookupGreLocalRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
821
-- Similar, but restricted to locally-defined things
822
lookupGreLocalRn_maybe rdr_name
823 824 825 826
  = lookupGreRn_help rdr_name lookup_fn
  where
    lookup_fn env = filter isLocalGRE (lookupGRE_RdrName rdr_name env)

Ian Lynagh's avatar
Ian Lynagh committed
827 828 829
lookupGreRn_help :: RdrName                     -- Only used in error message
                 -> (GlobalRdrEnv -> [GlobalRdrElt])    -- Lookup function
                 -> RnM (Maybe GlobalRdrElt)
830 831
-- Checks for exactly one match; reports deprecations
-- Returns Nothing, without error, if too few
Ian Lynagh's avatar
Ian Lynagh committed
832 833 834 835
lookupGreRn_help rdr_name lookup
  = do  { env <- getGlobalRdrEnv
        ; case lookup env of
            []    -> return Nothing
836
            [gre] -> do { addUsedRdrName True gre rdr_name
837
                        ; return (Just gre) }
Ian Lynagh's avatar
Ian Lynagh committed
838 839
            gres  -> do { addNameClashErrRn rdr_name gres
                        ; return (Just (head gres)) } }
840

Austin Seipp's avatar
Austin Seipp committed
841 842 843
{-
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
844
                Deprecations
Austin Seipp's avatar
Austin Seipp committed
845 846
*                                                      *
*********************************************************
847

848 849 850 851 852 853 854 855 856 857 858 859 860 861 862
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
863
-}
864

865
addUsedRdrName :: Bool -> GlobalRdrElt -> RdrName -> RnM ()
866
-- Record usage of imported RdrNames
867
addUsedRdrName warnIfDeprec gre rdr
868 869
  | isLocalGRE gre = return ()  -- No call to warnIfDeprecated
                                -- See Note [Handling of deprecations]
870
  | otherwise      = do { env <- getGblEnv
871
                        ; when warnIfDeprec $ warnIfDeprecated gre
872
                        ; updMutVar (tcg_used_rdrnames env)
Ian Lynagh's avatar
Ian Lynagh committed
873
                                    (\s -> Set.insert rdr s) }
874 875 876 877 878

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

885 886 887 888 889 890
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
891
                Just txt -> addWarn (mk_msg txt)
892 893 894 895 896 897 898 899 900 901 902
                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
903
    extra | imp_mod == moduleName name_mod = Outputable.empty
904 905 906 907 908 909 910 911 912
          | 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,
913
    case gre_par gre of                      -- or its parent, is warn'd
Ian Lynagh's avatar
Ian Lynagh committed
914
       ParentIs p -> mi_warn_fn iface p
915
       NoParent   -> Nothing
916

Austin Seipp's avatar
Austin Seipp committed
917
{-
918 919
Note [Used names with interface not loaded]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
920
It's (just) possible to find a used
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
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
938 939
*********************************************************
*                                                      *
Ian Lynagh's avatar
Ian Lynagh committed
940
                GHCi support
Austin Seipp's avatar
Austin Seipp committed
941 942
*                                                      *
*********************************************************
943

944 945 946 947 948 949
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
950
about "attempting to use module ‘D’ (./D.hs) which is not loaded"
951 952 953 954 955 956 957
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
958
-}
959 960 961

lookupQualifiedNameGHCi :: DynFlags -> Bool -> RdrName -> RnM (Maybe Name)
lookupQualifiedNameGHCi dflags is_ghci rdr_name
Simon Marlow's avatar
Simon Marlow committed
962
  | Just (mod,occ) <- isQual_maybe rdr_name
963 964 965 966 967 968 969
  , is_ghci
  , gopt Opt_ImplicitImportQualified dflags   -- Enables this GHCi behaviour
  , not (safeDirectImpsReq dflags)            -- See Note [Safe Haskell and GHCi]
  = -- We want to behave as we would for a source file import here,
    -- and respect hiddenness of modules/packages, hence loadSrcInterface.
    do { res <- loadSrcInterface_maybe doc mod False Nothing
       ; case res of
970
           Succeeded ifaces
971
             | (n:ns) <- [ name
972 973
                         | iface <- ifaces
                         , avail <- mi_exports iface
974 975
                         , name  <- availNames avail
                         , nameOccName name == occ ]
976
             -> ASSERT(all (==n) ns) return (Just n)
977 978 979 980 981

           _ -> -- Either we couldn't load the interface, or
                -- we could but we didn't find the name in it
                do { traceRn (text "lookupQualifiedNameGHCi" <+> ppr rdr_name)
                   ; return Nothing } }
Simon Marlow's avatar
Simon Marlow committed
982 983

  | otherwise
Simon Peyton Jones's avatar