Name.lhs 19.8 KB
Newer Older
1
%
Simon Marlow's avatar
Simon Marlow committed
2
% (c) The University of Glasgow 2006
3
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 5 6 7
%
\section[Name]{@Name@: to transmit name info from renamer to typechecker}

\begin{code}
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
-- |
-- #name_types#
-- GHC uses several kinds of name internally:
--
-- * 'OccName.OccName': see "OccName#name_types"
--
-- * 'RdrName.RdrName': see "RdrName#name_types"
--
-- *  'Name.Name' is the type of names that have had their scoping and binding resolved. They
--   have an 'OccName.OccName' but also a 'Unique.Unique' that disambiguates Names that have
--   the same 'OccName.OccName' and indeed is used for all 'Name.Name' comparison. Names
--   also contain information about where they originated from, see "Name#name_sorts"
--
-- * 'Id.Id': see "Id#name_types"
--
-- * 'Var.Var': see "Var#name_types"
--
-- #name_sorts#
-- Names are one of:
--
--  * External, if they name things declared in other modules. Some external
--    Names are wired in, i.e. they name primitives defined in the compiler itself
--
--  * Internal, if they name things in the module being compiled. Some internal
--    Names are system names, if they are names manufactured by the compiler
33

34 35
module Name (
	-- * The main types
36
	Name,					-- Abstract
37 38 39
	BuiltInSyntax(..),

	-- ** Creating 'Name's
40 41
	mkSystemName, mkSystemNameAt,
        mkInternalName, mkDerivedInternalName, 
42
	mkSystemVarName, mkSysTvName, 
43 44
        mkFCallName,
        mkExternalName, mkWiredInName,
45

46
	-- ** Manipulating and deconstructing 'Name's
47
	nameUnique, setNameUnique,
48
	nameOccName, nameModule, nameModule_maybe,
49
	tidyNameOcc, 
50
	hashName, localiseName,
51
  mkLocalisedOccName,
sof's avatar
sof committed
52

53
	nameSrcLoc, nameSrcSpan, pprNameDefnLoc, pprDefinedAt,
54

55
	-- ** Predicates on 'Name's
56
	isSystemName, isInternalName, isExternalName,
57 58 59
	isTyVarName, isTyConName, isDataConName, 
	isValName, isVarName,
	isWiredInName, isBuiltInSyntax,
60
	wiredInNameTyThing_maybe, 
61
	nameIsLocalOrFrom, stableNameCmp,
62 63

	-- * Class 'NamedThing' and overloaded friends
64
	NamedThing(..),
65
	getSrcLoc, getSrcSpan, getOccString,
66

67
 	pprInfixName, pprPrefixName, pprModulePrefix,
68 69 70

	-- Re-export the OccName stuff
	module OccName
71
    ) where
72

73 74
#include "Typeable.h"

75 76
import {-# SOURCE #-} TypeRep( TyThing )

Simon Marlow's avatar
Simon Marlow committed
77 78 79 80
import OccName
import Module
import SrcLoc
import Unique
81
import Util
Simon Marlow's avatar
Simon Marlow committed
82
import Maybes
83
import Binary
84
import StaticFlags
85
import FastTypes
Simon Marlow's avatar
Simon Marlow committed
86
import FastString
87
import Outputable
88

89
import Data.Data
90 91
\end{code}

92 93
%************************************************************************
%*									*
94
\subsection[Name-datatype]{The @Name@ datatype, and name construction}
95 96
%*									*
%************************************************************************
97
 
98
\begin{code}
99 100
-- | A unique, unambigious name for something, containing information about where
-- that thing originated.
101 102
data Name = Name {
		n_sort :: NameSort,	-- What sort of name it is
103
		n_occ  :: !OccName,	-- Its occurrence name
104 105
		n_uniq :: FastInt,      -- UNPACK doesn't work, recursive type
--(note later when changing Int# -> FastInt: is that still true about UNPACK?)
106
		n_loc  :: !SrcSpan	-- Definition site
107
	    }
Ian Lynagh's avatar
Ian Lynagh committed
108
    deriving Typeable
109

110 111 112 113
-- NOTE: we make the n_loc field strict to eliminate some potential
-- (and real!) space leaks, due to the fact that we don't look at
-- the SrcLoc in a Name all that often.

114
data NameSort
115
  = External Module
116
 
117
  | WiredIn Module TyThing BuiltInSyntax
118
	-- A variant of External, for wired-in things
119

120
  | Internal		-- A user-defined Id or TyVar
121 122 123 124
			-- defined in the module being compiled

  | System		-- A system-defined Id or TyVar.  Typically the
			-- OccName is very uninformative (like 's')
125

126 127
-- | BuiltInSyntax is for things like @(:)@, @[]@ and tuples, 
-- which have special syntactic forms.  They aren't in scope
128
-- as such.
129
data BuiltInSyntax = BuiltInSyntax | UserSyntax
130 131
\end{code}

132 133
Notes about the NameSorts:

134 135
1.  Initially, top-level Ids (including locally-defined ones) get External names, 
    and all other local Ids get Internal names
136

137
2.  Things with a External name are given C static labels, so they finally
138 139
    appear in the .o file's symbol table.  They appear in the symbol table
    in the form M.n.  If originally-local things have this property they
140
    must be made @External@ first.
141

142 143
3.  In the tidy-core phase, a External that is not visible to an importer
    is changed to Internal, and a Internal that is visible is changed to External
144 145

4.  A System Name differs in the following ways:
146 147 148 149 150 151 152 153 154
	a) has unique attached when printing dumps
	b) unifier eliminates sys tyvars in favour of user provs where possible

    Before anything gets printed in interface files or output code, it's
    fed through a 'tidy' processor, which zaps the OccNames to have
    unique names; and converts all sys-locals to user locals
    If any desugarer sys-locals have survived that far, they get changed to
    "ds1", "ds2", etc.

155 156 157 158 159 160 161 162
Built-in syntax => It's a syntactic form, not "in scope" (e.g. [])

Wired-in thing  => The thing (Id, TyCon) is fully known to the compiler, 
		   not read from an interface file. 
		   E.g. Bool, True, Int, Float, and many others

All built-in syntax is for wired-in things.

163 164 165 166 167
\begin{code}
nameUnique		:: Name -> Unique
nameOccName		:: Name -> OccName 
nameModule		:: Name -> Module
nameSrcLoc		:: Name -> SrcLoc
168
nameSrcSpan		:: Name -> SrcSpan
169

170
nameUnique  name = mkUniqueGrimily (iBox (n_uniq name))
171
nameOccName name = n_occ  name
172 173
nameSrcLoc  name = srcSpanStart (n_loc name)
nameSrcSpan name = n_loc  name
174 175
\end{code}

176 177 178 179 180 181
%************************************************************************
%*									*
\subsection{Predicates on names}
%*									*
%************************************************************************

182
\begin{code}
183 184 185 186
nameIsLocalOrFrom :: Module -> Name -> Bool
isInternalName	  :: Name -> Bool
isExternalName	  :: Name -> Bool
isSystemName	  :: Name -> Bool
187 188
isWiredInName	  :: Name -> Bool

189
isWiredInName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
190
isWiredInName _                               = False
191

192
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
193
wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ thing _}) = Just thing
twanvl's avatar
twanvl committed
194
wiredInNameTyThing_maybe _                                   = Nothing
195

twanvl's avatar
twanvl committed
196
isBuiltInSyntax :: Name -> Bool
197
isBuiltInSyntax (Name {n_sort = WiredIn _ _ BuiltInSyntax}) = True
twanvl's avatar
twanvl committed
198
isBuiltInSyntax _                                           = False
199

200 201
isExternalName (Name {n_sort = External _})    = True
isExternalName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
202
isExternalName _                               = False
203

204
isInternalName name = not (isExternalName name)
205

206
nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
twanvl's avatar
twanvl committed
207
nameModule_maybe :: Name -> Maybe Module
208 209
nameModule_maybe (Name { n_sort = External mod})    = Just mod
nameModule_maybe (Name { n_sort = WiredIn mod _ _}) = Just mod
twanvl's avatar
twanvl committed
210
nameModule_maybe _                                  = Nothing
211

212 213 214 215
nameIsLocalOrFrom from name
  | isExternalName name = from == nameModule name
  | otherwise		= True

216 217
isTyVarName :: Name -> Bool
isTyVarName name = isTvOcc (nameOccName name)
218

219 220 221
isTyConName :: Name -> Bool
isTyConName name = isTcOcc (nameOccName name)

222 223 224 225 226 227 228 229 230
isDataConName :: Name -> Bool
isDataConName name = isDataOcc (nameOccName name)

isValName :: Name -> Bool
isValName name = isValOcc (nameOccName name)

isVarName :: Name -> Bool
isVarName = isVarOcc . nameOccName

231
isSystemName (Name {n_sort = System}) = True
twanvl's avatar
twanvl committed
232
isSystemName _                        = False
233 234 235 236 237 238 239 240
\end{code}


%************************************************************************
%*									*
\subsection{Making names}
%*									*
%************************************************************************
241

242
\begin{code}
243 244
-- | Create a name which is (for now at least) local to the current module and hence
-- does not need a 'Module' to disambiguate it from other 'Name's
245
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
Simon Peyton Jones's avatar
Simon Peyton Jones committed
246 247 248 249
mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq
                                   , n_sort = Internal
                                   , n_occ = occ
                                   , n_loc = loc }
250 251 252 253 254 255
	-- NB: You might worry that after lots of huffing and
	-- puffing we might end up with two local names with distinct
	-- uniques, but the same OccName.  Indeed we can, but that's ok
	--	* the insides of the compiler don't care: they use the Unique
	--	* when printing for -ddump-xxx you can switch on -dppr-debug to get the
	--	  uniques if you get confused
256 257
        --      * for interface files we tidyCore first, which makes
        --        the OccNames distinct when they need to be
258

259 260 261 262 263
mkDerivedInternalName :: (OccName -> OccName) -> Unique -> Name -> Name
mkDerivedInternalName derive_occ uniq (Name { n_occ = occ, n_loc = loc })
  = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal
         , n_occ = derive_occ occ, n_loc = loc }

264
-- | Create a name which definitely originates in the given module
265
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
266
mkExternalName uniq mod occ loc 
267
  = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
268
           n_occ = occ, n_loc = loc }
269

270 271
-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
272
mkWiredInName mod occ uniq thing built_in
273
  = Name { n_uniq = getKeyFastInt uniq,
274
	   n_sort = WiredIn mod thing built_in,
275
	   n_occ = occ, n_loc = wiredInSrcSpan }
276

277
-- | Create a name brought into being by the compiler
278
mkSystemName :: Unique -> OccName -> Name
279 280 281 282 283
mkSystemName uniq occ = mkSystemNameAt uniq occ noSrcSpan

mkSystemNameAt :: Unique -> OccName -> SrcSpan -> Name
mkSystemNameAt uniq occ loc = Name { n_uniq = getKeyFastInt uniq, n_sort = System 
			           , n_occ = occ, n_loc = loc }
284

285 286
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
287

288
mkSysTvName :: Unique -> FastString -> Name
289
mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs)
290

291
-- | Make a name for a foreign call
292
mkFCallName :: Unique -> String -> Name
293 294
mkFCallName uniq str = mkInternalName uniq (mkVarOcc str) noSrcSpan
   -- The encoded string completely describes the ccall
295 296 297
\end{code}

\begin{code}
298 299 300
-- When we renumber/rename things, we need to be
-- able to change a Name's Unique to match the cached
-- one in the thing it's the name of.  If you know what I mean.
301
setNameUnique :: Name -> Unique -> Name
302
setNameUnique name uniq = name {n_uniq = getKeyFastInt uniq}
303

304 305 306 307 308 309
tidyNameOcc :: Name -> OccName -> Name
-- We set the OccName of a Name when tidying
-- In doing so, we change System --> Internal, so that when we print
-- it we don't get the unique by default.  It's tidy now!
tidyNameOcc name@(Name { n_sort = System }) occ = name { n_occ = occ, n_sort = Internal}
tidyNameOcc name 			    occ = name { n_occ = occ }
310

311
-- | Make the 'Name' into an internal name, regardless of what it was to begin with
312
localiseName :: Name -> Name
313
localiseName n = n { n_sort = Internal }
sof's avatar
sof committed
314 315
\end{code}

316 317 318 319 320
\begin{code}
-- |Create a localised variant of a name.  
--
-- If the name is external, encode the original's module name to disambiguate.
--
321 322
mkLocalisedOccName :: Module -> (Maybe String -> OccName -> OccName) -> Name -> OccName
mkLocalisedOccName this_mod mk_occ name = mk_occ origin (nameOccName name)
323
  where
324 325 326
    origin 
      | nameIsLocalOrFrom this_mod name = Nothing
      | otherwise                       = Just (moduleNameColons . moduleName . nameModule $ name)
327 328
\end{code}

329 330
%************************************************************************
%*									*
331
\subsection{Hashing and comparison}
332 333 334 335
%*									*
%************************************************************************

\begin{code}
336 337 338 339 340
hashName :: Name -> Int		-- ToDo: should really be Word
hashName name = getKey (nameUnique name) + 1
	-- The +1 avoids keys with lots of zeros in the ls bits, which 
	-- interacts badly with the cheap and cheerful multiplication in
	-- hashExpr
341

342 343
cmpName :: Name -> Name -> Ordering
cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2)
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363

stableNameCmp :: Name -> Name -> Ordering
-- Compare lexicographically
stableNameCmp (Name { n_sort = s1, n_occ = occ1 })
	      (Name { n_sort = s2, n_occ = occ2 })
  = (s1 `sort_cmp` s2) `thenCmp` (occ1 `compare` occ2)
    -- The ordinary compare on OccNames is lexicogrpahic
  where
    -- Later constructors are bigger
    sort_cmp (External m1) (External m2)       = m1 `stableModuleCmp` m2
    sort_cmp (External {}) _                   = LT
    sort_cmp (WiredIn {}) (External {})        = GT
    sort_cmp (WiredIn m1 _ _) (WiredIn m2 _ _) = m1 `stableModuleCmp` m2
    sort_cmp (WiredIn {})     _                = LT
    sort_cmp Internal         (External {})    = GT
    sort_cmp Internal         (WiredIn {})     = GT
    sort_cmp Internal         Internal         = EQ
    sort_cmp Internal         System           = LT
    sort_cmp System           System           = EQ
    sort_cmp System           _                = GT
364
\end{code}
365

366 367 368 369 370 371 372 373
%************************************************************************
%*									*
\subsection[Name-instances]{Instance declarations}
%*									*
%************************************************************************

\begin{code}
instance Eq Name where
374 375
    a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
    a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
376 377

instance Ord Name where
378 379
    a <= b = case (a `compare` b) of { LT -> True;  EQ -> True;  GT -> False }
    a <	 b = case (a `compare` b) of { LT -> True;  EQ -> False; GT -> False }
380 381 382
    a >= b = case (a `compare` b) of { LT -> False; EQ -> True;  GT -> True  }
    a >	 b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True  }
    compare a b = cmpName a b
383

384
instance Uniquable Name where
385
    getUnique = nameUnique
386

387
instance NamedThing Name where
388
    getName n = n
389 390 391 392 393 394

instance Data Name where
  -- don't traverse?
  toConstr _   = abstractConstr "Name"
  gunfold _ _  = error "gunfold"
  dataTypeOf _ = mkNoRepType "Name"
395 396
\end{code}

397 398 399 400 401 402 403 404
%************************************************************************
%*									*
\subsection{Binary}
%*									*
%************************************************************************

\begin{code}
instance Binary Name where
405 406 407
   put_ bh name =
      case getUserData bh of 
        UserData{ ud_put_name = put_name } -> put_name bh name
408

409 410 411
   get bh =
      case getUserData bh of
        UserData { ud_get_name = get_name } -> get_name bh
412
\end{code}
413

414 415 416 417 418
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
419 420 421

\begin{code}
instance Outputable Name where
422 423
    ppr name = pprName name

424 425 426
instance OutputableBndr Name where
    pprBndr _ name = pprName name

twanvl's avatar
twanvl committed
427
pprName :: Name -> SDoc
428
pprName n@(Name {n_sort = sort, n_uniq = u, n_occ = occ})
429
  = getPprStyle $ \ sty ->
430
    case sort of
431 432
      WiredIn mod _ builtin   -> pprExternal sty uniq mod occ n True  builtin
      External mod            -> pprExternal sty uniq mod occ n False UserSyntax
433 434
      System   		      -> pprSystem sty uniq occ
      Internal    	      -> pprInternal sty uniq occ
435
  where uniq = mkUniqueGrimily (iBox u)
436

437 438
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Name -> Bool -> BuiltInSyntax -> SDoc
pprExternal sty uniq mod occ name is_wired is_builtin
439
  | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
440 441 442
	-- In code style, always qualify
	-- ToDo: maybe we could print all wired-in things unqualified
	-- 	 in code style, to reduce symbol table bloat?
443
  | debugStyle sty = pp_mod <> ppr_occ_name occ
444 445 446 447
		     <> braces (hsep [if is_wired then ptext (sLit "(w)") else empty,
				      pprNameSpaceBrief (occNameSpace occ), 
		 		      pprUnique uniq])
  | BuiltInSyntax <- is_builtin = ppr_occ_name occ  -- Never qualify builtin syntax
448
  | otherwise                   = pprModulePrefix sty mod name <> ppr_occ_name occ
449 450 451
  where
    pp_mod | opt_SuppressModulePrefixes = empty
           | otherwise                  = ppr mod <> dot 
452

twanvl's avatar
twanvl committed
453
pprInternal :: PprStyle -> Unique -> OccName -> SDoc
454
pprInternal sty uniq occ
455
  | codeStyle sty  = pprUnique uniq
456
  | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ), 
457
				 		       pprUnique uniq])
458
  | dumpStyle sty  = ppr_occ_name occ <> ppr_underscore_unique uniq
459 460
			-- For debug dumps, we're not necessarily dumping
			-- tidied code, so we need to print the uniques.
461
  | otherwise      = ppr_occ_name occ	-- User style
462

463
-- Like Internal, except that we only omit the unique in Iface style
twanvl's avatar
twanvl committed
464
pprSystem :: PprStyle -> Unique -> OccName -> SDoc
465
pprSystem sty uniq occ
466
  | codeStyle sty  = pprUnique uniq
467
  | debugStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq
468
		     <> braces (pprNameSpaceBrief (occNameSpace occ))
469
  | otherwise	   = ppr_occ_name occ <> ppr_underscore_unique uniq
470 471 472
				-- If the tidy phase hasn't run, the OccName
				-- is unlikely to be informative (like 's'),
				-- so print the unique
473

474

475
pprModulePrefix :: PprStyle -> Module -> Name -> SDoc
476 477
-- Print the "M." part of a name, based on whether it's in scope or not
-- See Note [Printing original names] in HscTypes
478
pprModulePrefix sty mod name
479 480 481
  | opt_SuppressModulePrefixes = empty
  
  | otherwise
482
  = case qualName sty name of              -- See Outputable.QualifyName:
483 484 485 486 487 488
      NameQual modname -> ppr modname <> dot       -- Name is in scope       
      NameNotInScope1  -> ppr mod <> dot           -- Not in scope
      NameNotInScope2  -> ppr (modulePackageId mod) <> colon     -- Module not in
                          <> ppr (moduleName mod) <> dot         -- scope eithber
      _otherwise       -> empty

489 490 491 492 493 494 495
ppr_underscore_unique :: Unique -> SDoc
-- Print an underscore separating the name from its unique
-- But suppress it if we aren't printing the uniques anyway
ppr_underscore_unique uniq
  | opt_SuppressUniques = empty
  | otherwise		= char '_' <> pprUnique uniq

twanvl's avatar
twanvl committed
496
ppr_occ_name :: OccName -> SDoc
497
ppr_occ_name occ = ftext (occNameFS occ)
498 499
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
500 501 502

-- In code style, we Z-encode the strings.  The results of Z-encoding each FastString are
-- cached behind the scenes in the FastString implementation.
twanvl's avatar
twanvl committed
503
ppr_z_occ_name :: OccName -> SDoc
504
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
505

506 507
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
pprDefinedAt :: Name -> SDoc
pprDefinedAt name = ptext (sLit "Defined") <+> pprNameDefnLoc name

pprNameDefnLoc :: Name -> SDoc
-- Prints "at <loc>" or 
--     or "in <mod>" depending on what info is available
pprNameDefnLoc name 
  = case nameSrcLoc name of
         -- nameSrcLoc rather than nameSrcSpan
	 -- It seems less cluttered to show a location
	 -- rather than a span for the definition point
       RealSrcLoc s -> ptext (sLit "at") <+> ppr s
       UnhelpfulLoc s
         | isInternalName name || isSystemName name
         -> ptext (sLit "at") <+> ftext s
         | otherwise 
         -> ptext (sLit "in") <+> quotes (ppr (nameModule name))
525
\end{code}
526

527 528 529 530 531 532 533
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
534
-- | A class allowing convenient access to the 'Name' of various datatypes
535
class NamedThing a where
536
    getOccName :: a -> OccName
537 538 539
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
540 541 542 543
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
544
getSrcSpan	    :: NamedThing a => a -> SrcSpan
545
getOccString	    :: NamedThing a => a -> String
546

547
getSrcLoc	    = nameSrcLoc	   . getName
548
getSrcSpan	    = nameSrcSpan	   . getName
549
getOccString 	    = occNameString	   . getOccName
550 551 552 553 554 555

pprInfixName, pprPrefixName :: (Outputable a, NamedThing a) => a -> SDoc
-- See Outputable.pprPrefixVar, pprInfixVar; 
-- add parens or back-quotes as appropriate
pprInfixName  n = pprInfixVar  (isSymOcc (getOccName n)) (ppr n)
pprPrefixName n = pprPrefixVar (isSymOcc (getOccName n)) (ppr n)
556 557
\end{code}