[[project @ 2002-02-05 15:37:01 by simonpj]
simonpj**20020205153701
add renamer stuff
] {
addfile ./ghc/docs/comm/the-beast/renamer.html
hunk ./ghc/docs/comm/the-beast/renamer.html 1
+
+
+
+
+ The GHC Commentary - The Real Story about Variables, Ids, TyVars, and the like
+
+
+
+ The GHC Commentary - The Glorious Renamer
+
+
+(This section is, like most of the Commentary, rather incomplete.)
+
+The renamer sits between the parser and the typechecker.
+Roughly speaking, It has the type:
+
+ HsModule RdrName -> HsModule Name
+
+That is, it converts all the RdrNames to Names.
+
+ OccNames, RdrNames, and Names
+
+A RdrNames is pretty much just a string (for an unqualified name
+like "f") or a pair of strings (for a qualified name like "M.f").
+Well, not quite just strings, because in Haskell a name like "C" could mean a type
+constructor or data constructor, depending on context. So GHC defines a type
+OccName (defined in basicTypes/OccName.lhs) that is a pair of
+a FastString and a NameSpace indicating which name space the
+name is drawn from:
+
+ data OccName = OccName NameSpace EncodedFS
+
+The EncodedFS is a synonym for FastString indicating that the
+string is Z-encoded. (Details in OccName.lhs.)
+
+The name spaces are:
+
+- VarName: ordinary variables
+
- TvName: type variables
+
- DataName: data constructors
+
- TcClsName: type constructors and classes (in Haskell they share a name space)
+
+So a RdrName is defined thus:
+
+ data RdrName = RdrName Qual OccName
+
+ data Qual = Unqual
+
+ | Qual ModuleName -- A qualified name written by the user in source code
+ -- The module isn't necessarily the module where
+ -- the thing is defined; just the one from which it
+ -- is imported
+
+ | Orig ModuleName -- This is an *original* name; the module is the place
+ -- where the thing was defined
+
+The OrigName variant is used internally; it allows GHC to speak of RdrNames
+that refer to the original name of the thing.
+
+
+On the other hand, a Name:
+
+- Contains the original name for the thing.
+
- Contains a Unique that makes it easy to compare names for equality quickly.
+
- Contains a SrcLoc saying where the name was bound.
+
+The original name of an entity (type constructor, class, function etc) is
+the (module,name) pair describing where the thing was originally defined. So for example,
+if we have
+
+ module M where
+ f = e1
+ g = e2
+
+ module A where
+ import qualified M as Q
+ import M
+ a = Q.f + g
+
+then the RdrNames for "a", "Q.f" and "g" get replaced by the Names
+"A.a", "M.f", and "M.g" respectively.
+
+Names come in two flavours: Local and Global. The Global kind contain
+both a Module and an OccName
+Not all Names are qualifed. Local (e.g. lambda-bound) names are given Local Names
+
+
Rebindable syntax
+
+In Haskell when one writes "3" one gets "fromInteger 3", where
+"fromInteger" comes from the Prelude (regardless of whether the
+Prelude is in scope). If you want to completely redefine numbers,
+that becomes inconvenient. So GHC lets you say
+"-fno-implicit-prelude"; in that case, the "fromInteger" comes from
+whatever is in scope. (This is documented in the User Guide.)
+
+This feature is implemented as follows (I always forget).
+
+- Four HsSyn constructs (NegApp, NPlusKPat, HsIntegral, HsFractional)
+contain a Name (i.e. it is not parameterised).
+
- When the parser builds these constructs, it puts in the built-in Prelude
+Name (e.g. PrelNum.fromInteger).
+
- When the renamer encounters these constructs, it calls RnEnv.lookupSyntaxName.
+This checks for -fno-implicit-prelude; if not, it just returns the same Name;
+otherwise it takes the occurrence name of the Name, turns it into an unqualified RdrName, and looks
+it up in the environment. The returned name is plugged back into the construct.
+
- The typechecker uses the Name to generate the appropriate typing constraints.
+
+
+
+Last modified: Tue Nov 13 14:11:35 EST 2001
+
+
+
+
}