Name.lhs 18.3 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
	mkInternalName, mkSystemName, mkDerivedInternalName, 
41
	mkSystemVarName, mkSysTvName, 
42
	mkFCallName, mkIPName,
43
        mkTickBoxOpName,
44
	mkExternalName, mkWiredInName,
45

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

52
	nameSrcLoc, nameSrcSpan, pprNameLoc,
53

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

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

66
 	pprInfixName, pprPrefixName, pprModulePrefix,
67 68 69

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

72 73
#include "Typeable.h"

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

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

Simon Marlow's avatar
Simon Marlow committed
88
import Data.Array
89
import Data.Data
90
import Data.Word        ( Word32 )
91 92
\end{code}

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

111 112 113 114
-- 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.

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

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

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

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

133 134
Notes about the NameSorts:

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

138
2.  Things with a External name are given C static labels, so they finally
139 140
    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
141
    must be made @External@ first.
142

143 144
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
145 146

4.  A System Name differs in the following ways:
147 148 149 150 151 152 153 154 155
	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.

156 157 158 159 160 161 162 163
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.

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

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

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

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

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

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

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

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

205
isInternalName name = not (isExternalName name)
206

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

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

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

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

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

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

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

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


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

243
\begin{code}
244 245
-- | 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
246
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
Simon Peyton Jones's avatar
Simon Peyton Jones committed
247 248 249 250
mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq
                                   , n_sort = Internal
                                   , n_occ = occ
                                   , n_loc = loc }
251 252 253 254 255 256 257 258
	-- 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
	--	* for interface files we tidyCore first, which puts the uniques
	--	  into the print name (see setNameVisibility below)
259

260 261 262 263 264
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 }

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

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

278
-- | Create a name brought into being by the compiler
279
mkSystemName :: Unique -> OccName -> Name
280
mkSystemName uniq occ = Name { n_uniq = getKeyFastInt uniq, n_sort = System, 
281
			       n_occ = occ, n_loc = noSrcSpan }
282

283 284
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
285

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

289
-- | Make a name for a foreign call
290
mkFCallName :: Unique -> String -> Name
291
	-- The encoded string completely describes the ccall
292
mkFCallName uniq str =  Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
293
			       n_occ = mkVarOcc str, n_loc = noSrcSpan }
294

295

296 297
mkTickBoxOpName :: Unique -> String -> Name
mkTickBoxOpName uniq str 
298
   = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
299
	    n_occ = mkVarOcc str, n_loc = noSrcSpan }
300

301
-- | Make the name of an implicit parameter
302 303
mkIPName :: Unique -> OccName -> Name
mkIPName uniq occ
304
  = Name { n_uniq = getKeyFastInt uniq,
305
	   n_sort = Internal,
306
	   n_occ  = occ,
307
	   n_loc = noSrcSpan }
308 309 310
\end{code}

\begin{code}
311 312 313
-- 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.
314
setNameUnique :: Name -> Unique -> Name
315
setNameUnique name uniq = name {n_uniq = getKeyFastInt uniq}
316

317 318 319 320 321 322
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 }
323

324
-- | Make the 'Name' into an internal name, regardless of what it was to begin with
325
localiseName :: Name -> Name
326
localiseName n = n { n_sort = Internal }
sof's avatar
sof committed
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 344
cmpName :: Name -> Name -> Ordering
cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2)
\end{code}
345

346 347 348 349 350 351 352 353
%************************************************************************
%*									*
\subsection[Name-instances]{Instance declarations}
%*									*
%************************************************************************

\begin{code}
instance Eq Name where
354 355
    a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
    a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
356 357

instance Ord Name where
358 359
    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 }
360 361 362
    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
363

364
instance Uniquable Name where
365
    getUnique = nameUnique
366

367
instance NamedThing Name where
368
    getName n = n
369 370 371 372 373 374

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

377 378 379 380 381 382 383 384
%************************************************************************
%*									*
\subsection{Binary}
%*									*
%************************************************************************

\begin{code}
instance Binary Name where
385 386 387
   put_ bh name =
      case getUserData bh of 
        UserData{ ud_put_name = put_name } -> put_name bh name
388 389 390

   get bh = do
        i <- get bh
391
        return $! (ud_symtab (getUserData bh) ! fromIntegral (i::Word32))
392
\end{code}
393

394 395 396 397 398
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
399 400 401

\begin{code}
instance Outputable Name where
402 403
    ppr name = pprName name

404 405 406
instance OutputableBndr Name where
    pprBndr _ name = pprName name

twanvl's avatar
twanvl committed
407 408
pprName :: Name -> SDoc
pprName (Name {n_sort = sort, n_uniq = u, n_occ = occ})
409
  = getPprStyle $ \ sty ->
410
    case sort of
411 412
      WiredIn mod _ builtin   -> pprExternal sty uniq mod occ True  builtin
      External mod  	      -> pprExternal sty uniq mod occ False UserSyntax
413 414
      System   		      -> pprSystem sty uniq occ
      Internal    	      -> pprInternal sty uniq occ
415
  where uniq = mkUniqueGrimily (iBox u)
416

twanvl's avatar
twanvl committed
417
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
418
pprExternal sty uniq mod occ is_wired is_builtin
419
  | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
420 421 422
	-- In code style, always qualify
	-- ToDo: maybe we could print all wired-in things unqualified
	-- 	 in code style, to reduce symbol table bloat?
423 424 425 426 427 428
  | debugStyle sty = ppr mod <> dot <> ppr_occ_name occ
		     <> 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
  | otherwise		        = pprModulePrefix sty mod occ <> ppr_occ_name occ
429

twanvl's avatar
twanvl committed
430
pprInternal :: PprStyle -> Unique -> OccName -> SDoc
431
pprInternal sty uniq occ
432
  | codeStyle sty  = pprUnique uniq
433
  | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ), 
434
				 		       pprUnique uniq])
435
  | dumpStyle sty  = ppr_occ_name occ <> ppr_underscore_unique uniq
436 437
			-- For debug dumps, we're not necessarily dumping
			-- tidied code, so we need to print the uniques.
438
  | otherwise      = ppr_occ_name occ	-- User style
439

440
-- Like Internal, except that we only omit the unique in Iface style
twanvl's avatar
twanvl committed
441
pprSystem :: PprStyle -> Unique -> OccName -> SDoc
442
pprSystem sty uniq occ
443
  | codeStyle sty  = pprUnique uniq
444
  | debugStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq
445
		     <> braces (pprNameSpaceBrief (occNameSpace occ))
446
  | otherwise	   = ppr_occ_name occ <> ppr_underscore_unique uniq
447 448 449
				-- If the tidy phase hasn't run, the OccName
				-- is unlikely to be informative (like 's'),
				-- so print the unique
450

451 452 453 454 455

pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
-- Print the "M." part of a name, based on whether it's in scope or not
-- See Note [Printing original names] in HscTypes
pprModulePrefix sty mod occ
456 457 458
  | opt_SuppressModulePrefixes = empty
  
  | otherwise
459 460 461 462 463 464 465
  = case qualName sty mod occ of	           -- See Outputable.QualifyName:
      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

466 467 468 469 470 471 472
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
473
ppr_occ_name :: OccName -> SDoc
474
ppr_occ_name occ = ftext (occNameFS occ)
475 476
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
477 478 479

-- 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
480
ppr_z_occ_name :: OccName -> SDoc
481
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
482

483 484
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
485
pprNameLoc :: Name -> SDoc
Ian Lynagh's avatar
Ian Lynagh committed
486 487 488 489 490 491 492 493
pprNameLoc name = case nameSrcSpan name of
                  RealSrcSpan s ->
                      pprDefnLoc s
                  UnhelpfulSpan _
                   | isInternalName name || isSystemName name ->
                      ptext (sLit "<no location info>")
                   | otherwise ->
                      ptext (sLit "Defined in ") <> ppr (nameModule name)
494
\end{code}
495

496 497 498 499 500 501 502
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
503
-- | A class allowing convenient access to the 'Name' of various datatypes
504
class NamedThing a where
505
    getOccName :: a -> OccName
506 507 508
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
509 510 511 512
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
513
getSrcSpan	    :: NamedThing a => a -> SrcSpan
514
getOccString	    :: NamedThing a => a -> String
515

516
getSrcLoc	    = nameSrcLoc	   . getName
517
getSrcSpan	    = nameSrcSpan	   . getName
518
getOccString 	    = occNameString	   . getOccName
519 520 521 522 523 524

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)
525 526
\end{code}