Name.lhs 17.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
	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
import {-# SOURCE #-} TypeRep( TyThing )

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

Simon Marlow's avatar
Simon Marlow committed
85
import Data.Array
86
import Data.Word        ( Word32 )
87
88
\end{code}

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

106
107
108
109
-- 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.

110
data NameSort
111
  = External Module
112
 
113
  | WiredIn Module TyThing BuiltInSyntax
114
	-- A variant of External, for wired-in things
115

116
  | Internal		-- A user-defined Id or TyVar
117
118
119
120
			-- defined in the module being compiled

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

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

128
129
Notes about the NameSorts:

130
131
1.  Initially, top-level Ids (including locally-defined ones) get External names, 
    and all other local Ids get Internal names
132

133
2.  Things with a External name are given C static labels, so they finally
134
135
    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
136
    must be made @External@ first.
137

138
139
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
140
141

4.  A System Name differs in the following ways:
142
143
144
145
146
147
148
149
150
	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.

151
152
153
154
155
156
157
158
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.

159
160
161
162
163
\begin{code}
nameUnique		:: Name -> Unique
nameOccName		:: Name -> OccName 
nameModule		:: Name -> Module
nameSrcLoc		:: Name -> SrcLoc
164
nameSrcSpan		:: Name -> SrcSpan
165

166
nameUnique  name = mkUniqueGrimily (iBox (n_uniq name))
167
nameOccName name = n_occ  name
168
169
nameSrcLoc  name = srcSpanStart (n_loc name)
nameSrcSpan name = n_loc  name
170
171
\end{code}

172
173
174
175
176
177
%************************************************************************
%*									*
\subsection{Predicates on names}
%*									*
%************************************************************************

178
\begin{code}
179
180
181
182
nameIsLocalOrFrom :: Module -> Name -> Bool
isInternalName	  :: Name -> Bool
isExternalName	  :: Name -> Bool
isSystemName	  :: Name -> Bool
183
184
isWiredInName	  :: Name -> Bool

185
isWiredInName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
186
isWiredInName _                               = False
187

188
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
189
wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ thing _}) = Just thing
twanvl's avatar
twanvl committed
190
wiredInNameTyThing_maybe _                                   = Nothing
191

twanvl's avatar
twanvl committed
192
isBuiltInSyntax :: Name -> Bool
193
isBuiltInSyntax (Name {n_sort = WiredIn _ _ BuiltInSyntax}) = True
twanvl's avatar
twanvl committed
194
isBuiltInSyntax _                                           = False
195

196
197
isExternalName (Name {n_sort = External _})    = True
isExternalName (Name {n_sort = WiredIn _ _ _}) = True
twanvl's avatar
twanvl committed
198
isExternalName _                               = False
199

200
isInternalName name = not (isExternalName name)
201

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

208
209
210
211
nameIsLocalOrFrom from name
  | isExternalName name = from == nameModule name
  | otherwise		= True

212
213
isTyVarName :: Name -> Bool
isTyVarName name = isTvOcc (nameOccName name)
214

215
216
217
isTyConName :: Name -> Bool
isTyConName name = isTcOcc (nameOccName name)

218
219
220
221
222
223
224
225
226
isDataConName :: Name -> Bool
isDataConName name = isDataOcc (nameOccName name)

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

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

227
isSystemName (Name {n_sort = System}) = True
twanvl's avatar
twanvl committed
228
isSystemName _                        = False
229
230
231
232
233
234
235
236
\end{code}


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

238
\begin{code}
239
240
-- | 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
241
mkInternalName :: Unique -> OccName -> SrcSpan -> Name
242
mkInternalName uniq occ loc = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, n_occ = occ, n_loc = loc }
243
244
245
246
247
248
249
250
	-- 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)
251

252
253
254
255
256
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 }

257
-- | Create a name which definitely originates in the given module
258
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
259
mkExternalName uniq mod occ loc 
260
  = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
261
           n_occ = occ, n_loc = loc }
262

263
264
-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
265
mkWiredInName mod occ uniq thing built_in
266
  = Name { n_uniq = getKeyFastInt uniq,
267
	   n_sort = WiredIn mod thing built_in,
268
	   n_occ = occ, n_loc = wiredInSrcSpan }
269

270
-- | Create a name brought into being by the compiler
271
mkSystemName :: Unique -> OccName -> Name
272
mkSystemName uniq occ = Name { n_uniq = getKeyFastInt uniq, n_sort = System, 
273
			       n_occ = occ, n_loc = noSrcSpan }
274

275
276
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
277

278
279
mkSysTvName :: Unique -> FastString -> Name
mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs) 
280

281
-- | Make a name for a foreign call
282
mkFCallName :: Unique -> String -> Name
283
	-- The encoded string completely describes the ccall
284
mkFCallName uniq str =  Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
285
			       n_occ = mkVarOcc str, n_loc = noSrcSpan }
286

287

288
289
mkTickBoxOpName :: Unique -> String -> Name
mkTickBoxOpName uniq str 
290
   = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
291
	    n_occ = mkVarOcc str, n_loc = noSrcSpan }
292

293
-- | Make the name of an implicit parameter
294
295
mkIPName :: Unique -> OccName -> Name
mkIPName uniq occ
296
  = Name { n_uniq = getKeyFastInt uniq,
297
	   n_sort = Internal,
298
	   n_occ  = occ,
299
	   n_loc = noSrcSpan }
300
301
302
\end{code}

\begin{code}
303
304
305
-- 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.
306
setNameUnique :: Name -> Unique -> Name
307
setNameUnique name uniq = name {n_uniq = getKeyFastInt uniq}
308

309
310
311
312
313
314
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 }
315

316
-- | Make the 'Name' into an internal name, regardless of what it was to begin with
317
localiseName :: Name -> Name
318
localiseName n = n { n_sort = Internal }
sof's avatar
sof committed
319
320
\end{code}

321
322
%************************************************************************
%*									*
323
\subsection{Hashing and comparison}
324
325
326
327
%*									*
%************************************************************************

\begin{code}
328
329
330
331
332
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
333

334
335
336
cmpName :: Name -> Name -> Ordering
cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2)
\end{code}
337

338
339
340
341
342
343
344
345
%************************************************************************
%*									*
\subsection[Name-instances]{Instance declarations}
%*									*
%************************************************************************

\begin{code}
instance Eq Name where
346
347
    a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
    a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
348
349

instance Ord Name where
350
351
    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 }
352
353
354
    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
355

356
instance Uniquable Name where
357
    getUnique = nameUnique
358

359
instance NamedThing Name where
360
    getName n = n
361
362
\end{code}

363
364
365
366
367
368
369
370
%************************************************************************
%*									*
\subsection{Binary}
%*									*
%************************************************************************

\begin{code}
instance Binary Name where
371
372
373
   put_ bh name =
      case getUserData bh of 
        UserData{ ud_put_name = put_name } -> put_name bh name
374
375
376

   get bh = do
        i <- get bh
377
        return $! (ud_symtab (getUserData bh) ! fromIntegral (i::Word32))
378
\end{code}
379

380
381
382
383
384
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
385
386
387

\begin{code}
instance Outputable Name where
388
389
    ppr name = pprName name

390
391
392
instance OutputableBndr Name where
    pprBndr _ name = pprName name

twanvl's avatar
twanvl committed
393
394
pprName :: Name -> SDoc
pprName (Name {n_sort = sort, n_uniq = u, n_occ = occ})
395
  = getPprStyle $ \ sty ->
396
    case sort of
397
398
      WiredIn mod _ builtin   -> pprExternal sty uniq mod occ True  builtin
      External mod  	      -> pprExternal sty uniq mod occ False UserSyntax
399
400
      System   		      -> pprSystem sty uniq occ
      Internal    	      -> pprInternal sty uniq occ
401
  where uniq = mkUniqueGrimily (iBox u)
402

twanvl's avatar
twanvl committed
403
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
404
pprExternal sty uniq mod occ is_wired is_builtin
405
  | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
406
407
408
	-- In code style, always qualify
	-- ToDo: maybe we could print all wired-in things unqualified
	-- 	 in code style, to reduce symbol table bloat?
409
410
411
412
413
414
  | 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
415

twanvl's avatar
twanvl committed
416
pprInternal :: PprStyle -> Unique -> OccName -> SDoc
417
pprInternal sty uniq occ
418
  | codeStyle sty  = pprUnique uniq
419
  | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ), 
420
				 		       pprUnique uniq])
421
  | dumpStyle sty  = ppr_occ_name occ <> ppr_underscore_unique uniq
422
423
			-- For debug dumps, we're not necessarily dumping
			-- tidied code, so we need to print the uniques.
424
  | otherwise      = ppr_occ_name occ	-- User style
425

426
-- Like Internal, except that we only omit the unique in Iface style
twanvl's avatar
twanvl committed
427
pprSystem :: PprStyle -> Unique -> OccName -> SDoc
428
pprSystem sty uniq occ
429
  | codeStyle sty  = pprUnique uniq
430
  | debugStyle sty = ppr_occ_name occ <> ppr_underscore_unique uniq
431
		     <> braces (pprNameSpaceBrief (occNameSpace occ))
432
  | otherwise	   = ppr_occ_name occ <> ppr_underscore_unique uniq
433
434
435
				-- If the tidy phase hasn't run, the OccName
				-- is unlikely to be informative (like 's'),
				-- so print the unique
436

437
438
439
440
441
442
443
444
445
446
447
448

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
  = 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

449
450
451
452
453
454
455
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
456
ppr_occ_name :: OccName -> SDoc
457
ppr_occ_name occ = ftext (occNameFS occ)
458
459
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
460
461
462

-- 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
463
ppr_z_occ_name :: OccName -> SDoc
464
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
465

466
467
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
468
469
470
pprNameLoc :: Name -> SDoc
pprNameLoc name
  | isGoodSrcSpan loc = pprDefnLoc loc
471
  | isInternalName name || isSystemName name 
Ian Lynagh's avatar
Ian Lynagh committed
472
473
                      = ptext (sLit "<no location info>")
  | otherwise         = ptext (sLit "Defined in ") <> ppr (nameModule name)
474
  where loc = nameSrcSpan name
475
\end{code}
476

477
478
479
480
481
482
483
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
484
-- | A class allowing convenient access to the 'Name' of various datatypes
485
class NamedThing a where
486
    getOccName :: a -> OccName
487
488
489
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
490
491
492
493
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
494
getSrcSpan	    :: NamedThing a => a -> SrcSpan
495
getOccString	    :: NamedThing a => a -> String
496

497
getSrcLoc	    = nameSrcLoc	   . getName
498
getSrcSpan	    = nameSrcSpan	   . getName
499
getOccString 	    = occNameString	   . getOccName
500
501
502
503
504
505

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)
506
507
\end{code}