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

\begin{code}
module Name (
8 9
	-- Re-export the OccName stuff
	module OccName,
10

11 12
	-- The Name type
	Name,					-- Abstract
13
	BuiltInSyntax(..), 
14
	mkInternalName, mkSystemName,
15
	mkSystemVarName, mkSysTvName, 
16
	mkFCallName, mkIPName,
17
	mkExternalName, mkWiredInName,
18

19
	nameUnique, setNameUnique,
20
	nameOccName, nameModule, nameModule_maybe,
21
	tidyNameOcc, 
22
	hashName, localiseName,
sof's avatar
sof committed
23

24
	nameSrcLoc, nameParent, nameParent_maybe, isImplicitName, 
25

26
	isSystemName, isInternalName, isExternalName,
27
	isTyVarName, isWiredInName, isBuiltInSyntax,
28
	wiredInNameTyThing_maybe, 
29
	nameIsLocalOrFrom,
30
	
31 32
	-- Class NamedThing and overloaded friends
	NamedThing(..),
33
	getSrcLoc, getOccString
34
    ) where
35

36 37
#include "HsVersions.h"

38 39
import {-# SOURCE #-} TypeRep( TyThing )

40
import OccName		-- All of it
Simon Marlow's avatar
Simon Marlow committed
41
import Module		( Module )
42
import SrcLoc		( noSrcLoc, wiredInSrcLoc, SrcLoc )
43
import Unique		( Unique, Uniquable(..), getKey, pprUnique )
44
import Maybes		( orElse, isJust )
45
import FastString	( FastString, zEncodeFS )
46
import Outputable
47 48
\end{code}

49 50
%************************************************************************
%*									*
51
\subsection[Name-datatype]{The @Name@ datatype, and name construction}
52 53
%*									*
%************************************************************************
54
 
55
\begin{code}
56 57
data Name = Name {
		n_sort :: NameSort,	-- What sort of name it is
58
		n_occ  :: !OccName,	-- Its occurrence name
Simon Marlow's avatar
Simon Marlow committed
59
		n_uniq :: {-# UNPACK #-} !Unique,
60
		n_loc  :: !SrcLoc	-- Definition site
61 62
	    }

63 64 65 66
-- 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.

67
data NameSort
68 69 70 71 72
  = External Module (Maybe Name)
	-- (Just parent) => this Name is a subordinate name of 'parent'
	-- e.g. data constructor of a data type, method of a class
	-- Nothing => not a subordinate
 
73
  | WiredIn Module (Maybe Name) TyThing BuiltInSyntax
74
	-- A variant of External, for wired-in things
75

76
  | Internal		-- A user-defined Id or TyVar
77 78 79 80
			-- defined in the module being compiled

  | System		-- A system-defined Id or TyVar.  Typically the
			-- OccName is very uninformative (like 's')
81 82 83 84 85

data BuiltInSyntax = BuiltInSyntax | UserSyntax
-- BuiltInSyntax is for things like (:), [], tuples etc, 
-- which have special syntactic forms.  They aren't "in scope"
-- as such.
86 87
\end{code}

88 89
Notes about the NameSorts:

90 91
1.  Initially, top-level Ids (including locally-defined ones) get External names, 
    and all other local Ids get Internal names
92

93
2.  Things with a External name are given C static labels, so they finally
94 95
    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
96
    must be made @External@ first.
97

98 99
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
100 101

4.  A System Name differs in the following ways:
102 103 104 105 106 107 108 109 110
	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.

111 112 113 114 115 116 117 118
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.

119 120 121 122 123 124 125 126 127 128 129 130
\begin{code}
nameUnique		:: Name -> Unique
nameOccName		:: Name -> OccName 
nameModule		:: Name -> Module
nameSrcLoc		:: Name -> SrcLoc

nameUnique  name = n_uniq name
nameOccName name = n_occ  name
nameSrcLoc  name = n_loc  name
\end{code}

\begin{code}
131 132 133 134
nameIsLocalOrFrom :: Module -> Name -> Bool
isInternalName	  :: Name -> Bool
isExternalName	  :: Name -> Bool
isSystemName	  :: Name -> Bool
135 136
isWiredInName	  :: Name -> Bool

137 138
isWiredInName (Name {n_sort = WiredIn _ _ _ _}) = True
isWiredInName other			        = False
139

140
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
141 142
wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ _ thing _}) = Just thing
wiredInNameTyThing_maybe other				       = Nothing
143

144 145 146 147 148 149
isBuiltInSyntax (Name {n_sort = WiredIn _ _ _ BuiltInSyntax}) = True
isBuiltInSyntax other			 		      = False

isExternalName (Name {n_sort = External _ _})    = True
isExternalName (Name {n_sort = WiredIn _ _ _ _}) = True
isExternalName other	                         = False
150

151
isInternalName name = not (isExternalName name)
152

153
nameParent_maybe :: Name -> Maybe Name
154 155 156
nameParent_maybe (Name {n_sort = External _ p})    = p
nameParent_maybe (Name {n_sort = WiredIn _ p _ _}) = p
nameParent_maybe other	                           = Nothing
157 158 159 160 161 162

nameParent :: Name -> Name
nameParent name = case nameParent_maybe name of
			Just parent -> parent
			Nothing     -> name

163 164
isImplicitName :: Name -> Bool
-- An Implicit Name is one has a parent; that is, one whose definition
165
-- derives from the parent thing
166 167
isImplicitName name = isJust (nameParent_maybe name)

168
nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
169 170 171
nameModule_maybe (Name { n_sort = External mod _})    = Just mod
nameModule_maybe (Name { n_sort = WiredIn mod _ _ _}) = Just mod
nameModule_maybe name				      = Nothing
172

173 174 175 176
nameIsLocalOrFrom from name
  | isExternalName name = from == nameModule name
  | otherwise		= True

177 178
isTyVarName :: Name -> Bool
isTyVarName name = isTvOcc (nameOccName name)
179 180 181 182 183 184 185 186 187 188 189

isSystemName (Name {n_sort = System}) = True
isSystemName other		      = False
\end{code}


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

191
\begin{code}
192 193
mkInternalName :: Unique -> OccName -> SrcLoc -> Name
mkInternalName uniq occ loc = Name { n_uniq = uniq, n_sort = Internal, n_occ = occ, n_loc = loc }
194 195 196 197 198 199 200 201
	-- 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)
202

203 204 205 206
mkExternalName :: Unique -> Module -> OccName -> Maybe Name -> SrcLoc -> Name
mkExternalName uniq mod occ mb_parent loc 
  = Name { n_uniq = uniq, n_sort = External mod mb_parent,
           n_occ = occ, n_loc = loc }
207

208 209 210
mkWiredInName :: Module -> OccName -> Unique 
	      -> Maybe Name -> TyThing -> BuiltInSyntax -> Name
mkWiredInName mod occ uniq mb_parent thing built_in
211
  = Name { n_uniq = uniq,
212
	   n_sort = WiredIn mod mb_parent thing built_in,
213
	   n_occ = occ, n_loc = wiredInSrcLoc }
214

215 216 217 218
mkSystemName :: Unique -> OccName -> Name
mkSystemName uniq occ = Name { n_uniq = uniq, n_sort = System, 
			       n_occ = occ, n_loc = noSrcLoc }

219 220
mkSystemVarName :: Unique -> FastString -> Name
mkSystemVarName uniq fs = mkSystemName uniq (mkVarOccFS fs)
221

222 223
mkSysTvName :: Unique -> FastString -> Name
mkSysTvName uniq fs = mkSystemName uniq (mkOccNameFS tvName fs) 
224

225
mkFCallName :: Unique -> String -> Name
226
	-- The encoded string completely describes the ccall
227
mkFCallName uniq str =  Name { n_uniq = uniq, n_sort = Internal, 
228
			       n_occ = mkVarOcc str, n_loc = noSrcLoc }
229

230 231 232
mkIPName :: Unique -> OccName -> Name
mkIPName uniq occ
  = Name { n_uniq = uniq,
233
	   n_sort = Internal,
234
	   n_occ  = occ,
235
	   n_loc = noSrcLoc }
236 237 238
\end{code}

\begin{code}
239 240 241
-- 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.
242
setNameUnique name uniq = name {n_uniq = uniq}
243

244 245 246 247 248 249
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 }
250

251
localiseName :: Name -> Name
252
localiseName n = n { n_sort = Internal }
sof's avatar
sof committed
253 254 255
\end{code}


256 257 258 259 260 261 262
%************************************************************************
%*									*
\subsection{Predicates and selectors}
%*									*
%************************************************************************

\begin{code}
263
hashName :: Name -> Int
264
hashName name = getKey (nameUnique name)
265 266
\end{code}

267

268 269 270 271 272 273 274
%************************************************************************
%*									*
\subsection[Name-instances]{Instance declarations}
%*									*
%************************************************************************

\begin{code}
275
cmpName n1 n2 = n_uniq n1 `compare` n_uniq n2
276 277 278 279
\end{code}

\begin{code}
instance Eq Name where
280 281
    a == b = case (a `compare` b) of { EQ -> True;  _ -> False }
    a /= b = case (a `compare` b) of { EQ -> False; _ -> True }
282 283

instance Ord Name where
284 285
    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 }
286 287 288
    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
289

290
instance Uniquable Name where
291
    getUnique = nameUnique
292

293
instance NamedThing Name where
294
    getName n = n
295 296 297
\end{code}


298 299 300 301 302
%************************************************************************
%*									*
\subsection{Pretty printing}
%*									*
%************************************************************************
303 304 305

\begin{code}
instance Outputable Name where
306 307
    ppr name = pprName name

308 309 310
instance OutputableBndr Name where
    pprBndr _ name = pprName name

Simon Marlow's avatar
Simon Marlow committed
311
pprName name@(Name {n_sort = sort, n_uniq = uniq, n_occ = occ})
312
  = getPprStyle $ \ sty ->
313
    case sort of
314 315 316 317
      WiredIn mod _ _ builtin -> pprExternal sty uniq mod occ True  builtin
      External mod _  	      -> pprExternal sty uniq mod occ False UserSyntax
      System   		      -> pprSystem sty uniq occ
      Internal    	      -> pprInternal sty uniq occ
318

319
pprExternal sty uniq mod occ is_wired is_builtin
Simon Marlow's avatar
Simon Marlow committed
320
  | codeStyle sty        = ppr mod <> char '_' <> ppr_z_occ_name occ
321 322 323
	-- 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
324 325 326 327
 | 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])
328
  | BuiltInSyntax <- is_builtin  = ppr_occ_name occ
329
	-- never qualify builtin syntax
Simon Marlow's avatar
Simon Marlow committed
330 331 332
  | Just mod <- qualName sty mod occ = ppr mod <> dot <> ppr_occ_name occ
        -- the PrintUnqualified tells us how to qualify this Name, if at all
  | otherwise		          = ppr_occ_name occ
333

334
pprInternal sty uniq occ
335
  | codeStyle sty  = pprUnique uniq
336
  | debugStyle sty = ppr_occ_name occ <> braces (hsep [pprNameSpaceBrief (occNameSpace occ), 
337
				 		       pprUnique uniq])
338 339 340
  | 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.
341
  | otherwise      = ppr_occ_name occ	-- User style
342

343 344
-- Like Internal, except that we only omit the unique in Iface style
pprSystem sty uniq occ
345
  | codeStyle sty  = pprUnique uniq
346
  | debugStyle sty = ppr_occ_name occ <> char '_' <> pprUnique uniq
347
		     <> braces (pprNameSpaceBrief (occNameSpace occ))
348
  | otherwise	   = ppr_occ_name occ <> char '_' <> pprUnique uniq
349 350 351
				-- If the tidy phase hasn't run, the OccName
				-- is unlikely to be informative (like 's'),
				-- so print the unique
352

353
ppr_occ_name occ = ftext (occNameFS occ)
354 355
	-- Don't use pprOccName; instead, just print the string of the OccName; 
	-- we print the namespace in the debug stuff above
356 357 358 359

-- In code style, we Z-encode the strings.  The results of Z-encoding each FastString are
-- cached behind the scenes in the FastString implementation.
ppr_z_occ_name occ = ftext (zEncodeFS (occNameFS occ))
360
\end{code}
361

362 363 364 365 366 367 368 369
%************************************************************************
%*									*
\subsection{Overloaded functions related to Names}
%*									*
%************************************************************************

\begin{code}
class NamedThing a where
370
    getOccName :: a -> OccName
371 372 373
    getName    :: a -> Name

    getOccName n = nameOccName (getName n)	-- Default method
374 375 376 377
\end{code}

\begin{code}
getSrcLoc	    :: NamedThing a => a -> SrcLoc
378
getOccString	    :: NamedThing a => a -> String
379

380
getSrcLoc	    = nameSrcLoc	   . getName
381
getOccString 	    = occNameString	   . getOccName
382 383
\end{code}