Name.lhs 17.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,
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 67 68 69

 	pprInfixName, pprPrefixName,

	-- 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 87
\end{code}

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

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

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

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

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

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

127 128
Notes about the NameSorts:

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

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

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

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

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

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

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

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

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

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

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

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

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

199
isInternalName name = not (isExternalName name)
200

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

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

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

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

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

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

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

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


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

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

251
-- | Create a name which definitely originates in the given module
252
mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
253
mkExternalName uniq mod occ loc 
254
  = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
255
           n_occ = occ, n_loc = loc }
256

257 258
-- | Create a name which is actually defined by the compiler itself
mkWiredInName :: Module -> OccName -> Unique -> TyThing -> BuiltInSyntax -> Name
259
mkWiredInName mod occ uniq thing built_in
260
  = Name { n_uniq = getKeyFastInt uniq,
261
	   n_sort = WiredIn mod thing built_in,
262
	   n_occ = occ, n_loc = wiredInSrcSpan }
263

264
-- | Create a name brought into being by the compiler
265
mkSystemName :: Unique -> OccName -> Name
266
mkSystemName uniq occ = Name { n_uniq = getKeyFastInt uniq, n_sort = System, 
267
			       n_occ = occ, n_loc = noSrcSpan }
268

269 270
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
271

272 273
mkSysTvName :: Unique -> FastString -> Name
mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs) 
274

275
-- | Make a name for a foreign call
276
mkFCallName :: Unique -> String -> Name
277
	-- The encoded string completely describes the ccall
278
mkFCallName uniq str =  Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
279
			       n_occ = mkVarOcc str, n_loc = noSrcSpan }
280

281

282 283
mkTickBoxOpName :: Unique -> String -> Name
mkTickBoxOpName uniq str 
284
   = Name { n_uniq = getKeyFastInt uniq, n_sort = Internal, 
285
	    n_occ = mkVarOcc str, n_loc = noSrcSpan }
286

287
-- | Make the name of an implicit parameter
288 289
mkIPName :: Unique -> OccName -> Name
mkIPName uniq occ
290
  = Name { n_uniq = getKeyFastInt uniq,
291
	   n_sort = Internal,
292
	   n_occ  = occ,
293
	   n_loc = noSrcSpan }
294 295 296
\end{code}

\begin{code}
297 298 299
-- 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.
300
setNameUnique :: Name -> Unique -> Name
301
setNameUnique name uniq = name {n_uniq = getKeyFastInt uniq}
302

303 304 305 306 307 308
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 }
309

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

315 316
%************************************************************************
%*									*
317
\subsection{Hashing and comparison}
318 319 320 321
%*									*
%************************************************************************

\begin{code}
322 323 324 325 326
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
327

328 329 330
cmpName :: Name -> Name -> Ordering
cmpName n1 n2 = iBox (n_uniq n1) `compare` iBox (n_uniq n2)
\end{code}
331

332 333 334 335 336 337 338 339
%************************************************************************
%*									*
\subsection[Name-instances]{Instance declarations}
%*									*
%************************************************************************

\begin{code}
instance Eq Name where
340 341
    a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
    a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
342 343

instance Ord Name where
344 345
    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 }
346 347 348
    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
349

350
instance Uniquable Name where
351
    getUnique = nameUnique
352

353
instance NamedThing Name where
354
    getName n = n
355 356
\end{code}

357 358 359 360 361 362 363 364
%************************************************************************
%*									*
\subsection{Binary}
%*									*
%************************************************************************

\begin{code}
instance Binary Name where
365 366 367
   put_ bh name =
      case getUserData bh of 
        UserData{ ud_put_name = put_name } -> put_name bh name
368 369 370 371 372

   get bh = do
        i <- get bh
        return $! (ud_symtab (getUserData bh) ! i)
\end{code}
373

374 375 376 377 378
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
379 380 381

\begin{code}
instance Outputable Name where
382 383
    ppr name = pprName name

384 385 386
instance OutputableBndr Name where
    pprBndr _ name = pprName name

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

twanvl's avatar
twanvl committed
397
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
398
pprExternal sty uniq mod occ is_wired is_builtin
Simon Marlow's avatar
Simon Marlow committed
399
  | codeStyle sty        = ppr mod <> char '_' <> ppr_z_occ_name occ
400 401 402
	-- In code style, always qualify
	-- ToDo: maybe we could print all wired-in things unqualified
	-- 	 in code style, to reduce symbol table bloat?
Simon Marlow's avatar
Simon Marlow committed
403
 | debugStyle sty       = ppr mod <> dot <> ppr_occ_name occ
Ian Lynagh's avatar
Ian Lynagh committed
404
		<> braces (hsep [if is_wired then ptext (sLit "(w)") else empty,
Simon Marlow's avatar
Simon Marlow committed
405 406
				 pprNameSpaceBrief (occNameSpace occ), 
		 		 pprUnique uniq])
407
  | BuiltInSyntax <- is_builtin  = ppr_occ_name occ
408
	-- never qualify builtin syntax
409 410 411 412 413
  | NameQual modname <- qual_name = ppr modname <> dot <> ppr_occ_name occ
        -- see HscTypes.mkPrintUnqualified and Outputable.QualifyName:
  | NameNotInScope1 <- qual_name  = ppr mod <> dot <> ppr_occ_name occ
  | NameNotInScope2 <- qual_name  = ppr (modulePackageId mod) <> char ':' <>
                                    ppr (moduleName mod) <> dot <> ppr_occ_name occ
Simon Marlow's avatar
Simon Marlow committed
414
  | otherwise		          = ppr_occ_name occ
415
  where qual_name = qualName sty mod occ
416

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

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

438 439 440 441 442 443 444
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
445
ppr_occ_name :: OccName -> SDoc
446
ppr_occ_name occ = ftext (occNameFS occ)
447 448
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
449 450 451

-- 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
452
ppr_z_occ_name :: OccName -> SDoc
453
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
454

455 456
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
457 458 459
pprNameLoc :: Name -> SDoc
pprNameLoc name
  | isGoodSrcSpan loc = pprDefnLoc loc
460
  | isInternalName name || isSystemName name 
Ian Lynagh's avatar
Ian Lynagh committed
461 462
                      = ptext (sLit "<no location info>")
  | otherwise         = ptext (sLit "Defined in ") <> ppr (nameModule name)
463
  where loc = nameSrcSpan name
464
\end{code}
465

466 467 468 469 470 471 472
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
473
-- | A class allowing convenient access to the 'Name' of various datatypes
474
class NamedThing a where
475
    getOccName :: a -> OccName
476 477 478
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
479 480 481 482
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
483
getSrcSpan	    :: NamedThing a => a -> SrcSpan
484
getOccString	    :: NamedThing a => a -> String
485

486
getSrcLoc	    = nameSrcLoc	   . getName
487
getSrcSpan	    = nameSrcSpan	   . getName
488
getOccString 	    = occNameString	   . getOccName
489 490 491 492 493 494

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)
495 496
\end{code}