Name.lhs 17 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 FastTypes
Simon Marlow's avatar
Simon Marlow committed
81
import FastString
82
import Outputable
83

Simon Marlow's avatar
Simon Marlow committed
84
import Data.Array
85 86
\end{code}

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

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

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

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

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

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

126 127
Notes about the NameSorts:

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

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

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

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

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

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

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

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

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

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

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

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

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

198
isInternalName name = not (isExternalName name)
199

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

280

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

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

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

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

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

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

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

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

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

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

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

349
instance Uniquable Name where
350
    getUnique = nameUnique
351

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

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

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

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

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

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

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

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

twanvl's avatar
twanvl committed
396
pprExternal :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
397
pprExternal sty uniq mod occ is_wired is_builtin
Simon Marlow's avatar
Simon Marlow committed
398
  | codeStyle sty        = ppr mod <> char '_' <> ppr_z_occ_name occ
399 400 401
	-- 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
402
 | debugStyle sty       = ppr mod <> dot <> ppr_occ_name occ
Ian Lynagh's avatar
Ian Lynagh committed
403
		<> braces (hsep [if is_wired then ptext (sLit "(w)") else empty,
Simon Marlow's avatar
Simon Marlow committed
404 405
				 pprNameSpaceBrief (occNameSpace occ), 
		 		 pprUnique uniq])
406
  | BuiltInSyntax <- is_builtin  = ppr_occ_name occ
407
	-- never qualify builtin syntax
408 409 410 411 412
  | 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
413
  | otherwise		          = ppr_occ_name occ
414
  where qual_name = qualName sty mod 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 422 423
  | dumpStyle sty  = ppr_occ_name occ <> char '_' <> pprUnique uniq
			-- 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 <> char '_' <> pprUnique uniq
431
		     <> braces (pprNameSpaceBrief (occNameSpace occ))
432
  | otherwise	   = ppr_occ_name occ <> char '_' <> pprUnique 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

twanvl's avatar
twanvl committed
437
ppr_occ_name :: OccName -> SDoc
438
ppr_occ_name occ = ftext (occNameFS occ)
439 440
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
441 442 443

-- 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
444
ppr_z_occ_name :: OccName -> SDoc
445
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
446

447 448
-- Prints (if mod information is available) "Defined at <loc>" or 
--  "Defined in <mod>" information for a Name.
449 450 451
pprNameLoc :: Name -> SDoc
pprNameLoc name
  | isGoodSrcSpan loc = pprDefnLoc loc
452
  | isInternalName name || isSystemName name 
Ian Lynagh's avatar
Ian Lynagh committed
453 454
                      = ptext (sLit "<no location info>")
  | otherwise         = ptext (sLit "Defined in ") <> ppr (nameModule name)
455
  where loc = nameSrcSpan name
456
\end{code}
457

458 459 460 461 462 463 464
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
465
-- | A class allowing convenient access to the 'Name' of various datatypes
466
class NamedThing a where
467
    getOccName :: a -> OccName
468 469 470
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
471 472 473 474
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
475
getSrcSpan	    :: NamedThing a => a -> SrcSpan
476
getOccString	    :: NamedThing a => a -> String
477

478
getSrcLoc	    = nameSrcLoc	   . getName
479
getSrcSpan	    = nameSrcSpan	   . getName
480
getOccString 	    = occNameString	   . getOccName
481 482 483 484 485 486

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)
487 488
\end{code}