From fcd0dea6bcbe44f992e2a643ae3261e44df17961 Mon Sep 17 00:00:00 2001 From: simonpj Date: Tue, 5 Feb 2002 15:37:01 +0000 Subject: [PATCH] [project @ 2002-02-05 15:37:01 by simonpj] add renamer stuff --- ghc/docs/comm/the-beast/renamer.html | 114 ++++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) create mode 100644 ghc/docs/comm/the-beast/renamer.html diff --git a/ghc/docs/comm/the-beast/renamer.html b/ghc/docs/comm/the-beast/renamer.html new file mode 100644 index 0000000..038a941 --- /dev/null +++ b/ghc/docs/comm/the-beast/renamer.html @@ -0,0 +1,114 @@ + + + + + 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 + + + + -- 1.7.10.4