Typo in comment
[ghc.git] / compiler / basicTypes / Name.lhs
index 281ae93..0647c60 100644 (file)
@@ -5,6 +5,8 @@
 \section[Name]{@Name@: to transmit name info from renamer to typechecker}
 
 \begin{code}
+{-# LANGUAGE DeriveDataTypeable #-}
+
 -- |
 -- #name_types#
 -- GHC uses several kinds of name internally:
@@ -70,9 +72,8 @@ module Name (
         module OccName
     ) where
 
-#include "Typeable.h"
-
 import {-# SOURCE #-} TypeRep( TyThing )
+import {-# SOURCE #-} PrelNames( liftedTypeKindTyConKey )
 
 import OccName
 import Module
@@ -134,15 +135,19 @@ Notes about the NameSorts:
 1.  Initially, top-level Ids (including locally-defined ones) get External names,
     and all other local Ids get Internal names
 
-2.  Things with a External name are given C static labels, so they finally
+2.  In any invocation of GHC, an External Name for "M.x" has one and only one
+    unique.  This unique association is ensured via the Name Cache; 
+    see Note [The Name Cache] in IfaceEnv.
+
+3.  Things with a External name are given C static labels, so they finally
     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
     must be made @External@ first.
 
-3.  In the tidy-core phase, a External that is not visible to an importer
+4.  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
 
-4.  A System Name differs in the following ways:
+5.  A System Name differs in the following ways:
         a) has unique attached when printing dumps
         b) unifier eliminates sys tyvars in favour of user provs where possible
 
@@ -271,6 +276,9 @@ mkDerivedInternalName derive_occ uniq (Name { n_occ = occ, n_loc = loc })
 
 -- | Create a name which definitely originates in the given module
 mkExternalName :: Unique -> Module -> OccName -> SrcSpan -> Name
+-- WATCH OUT! External Names should be in the Name Cache
+-- (see Note [The Name Cache] in IfaceEnv), so don't just call mkExternalName
+-- with some fresh unique without populating the Name Cache
 mkExternalName uniq mod occ loc
   = Name { n_uniq = getKeyFastInt uniq, n_sort = External mod,
            n_occ = occ, n_loc = loc }
@@ -355,7 +363,7 @@ stableNameCmp :: Name -> Name -> Ordering
 stableNameCmp (Name { n_sort = s1, n_occ = occ1 })
               (Name { n_sort = s2, n_occ = occ2 })
   = (s1 `sort_cmp` s2) `thenCmp` (occ1 `compare` occ2)
-    -- The ordinary compare on OccNames is lexicogrpahic
+    -- The ordinary compare on OccNames is lexicographic
   where
     -- Later constructors are bigger
     sort_cmp (External m1) (External m2)       = m1 `stableModuleCmp` m2
@@ -436,17 +444,17 @@ instance OutputableBndr Name where
 
 
 pprName :: Name -> SDoc
-pprName n@(Name {n_sort = sort, n_uniq = u, n_occ = occ})
+pprName (Name {n_sort = sort, n_uniq = u, n_occ = occ})
   = getPprStyle $ \ sty ->
     case sort of
-      WiredIn mod _ builtin   -> pprExternal sty uniq mod occ True  builtin
-      External mod            -> pprExternal sty uniq mod occ False UserSyntax
+      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
   where uniq = mkUniqueGrimily (iBox u)
 
-pprExternal :: PprStyle -> Unique -> Module -> OccName -> Name -> Bool -> BuiltInSyntax -> SDoc
-pprExternal sty uniq mod occ name is_wired is_builtin
+pprExternal :: PprStyle -> Unique -> Module -> OccName -> Bool -> BuiltInSyntax -> SDoc
+pprExternal sty uniq mod occ is_wired is_builtin
   | codeStyle sty = ppr mod <> char '_' <> ppr_z_occ_name occ
         -- In code style, always qualify
         -- ToDo: maybe we could print all wired-in things unqualified
@@ -456,7 +464,7 @@ pprExternal sty uniq mod occ name is_wired is_builtin
                                       pprNameSpaceBrief (occNameSpace occ),
                                       pprUnique uniq])
   | BuiltInSyntax <- is_builtin = ppr_occ_name occ  -- Never qualify builtin syntax
-  | otherwise                   = pprModulePrefix sty mod name <> ppr_occ_name occ
+  | otherwise                   = pprModulePrefix sty mod occ <> ppr_occ_name occ
   where
     pp_mod = sdocWithDynFlags $ \dflags ->
              if gopt Opt_SuppressModulePrefixes dflags
@@ -485,18 +493,18 @@ pprSystem sty uniq occ
                                 -- so print the unique
 
 
-pprModulePrefix :: PprStyle -> Module -> Name -> SDoc
+pprModulePrefix :: PprStyle -> Module -> OccName -> SDoc
 -- Print the "M." part of a name, based on whether it's in scope or not
 -- See Note [Printing original names] in HscTypes
-pprModulePrefix sty mod name = sdocWithDynFlags $ \dflags ->
+pprModulePrefix sty mod occ = sdocWithDynFlags $ \dflags ->
   if gopt Opt_SuppressModulePrefixes dflags
   then empty
   else
-    case qualName sty name of              -- See Outputable.QualifyName:
+    case qualName sty mod occ of              -- See Outputable.QualifyName:
       NameQual modname -> ppr modname <> dot       -- Name is in scope
       NameNotInScope1  -> ppr mod <> dot           -- Not in scope
-      NameNotInScope2  -> ppr (modulePackageId mod) <> colon     -- Module not in
-                          <> ppr (moduleName mod) <> dot         -- scope eithber
+      NameNotInScope2  -> ppr (modulePackageKey mod) <> colon     -- Module not in
+                          <> ppr (moduleName mod) <> dot         -- scope either
       _otherwise       -> empty
 
 ppr_underscore_unique :: Unique -> SDoc
@@ -566,7 +574,26 @@ getOccString        = occNameString        . getOccName
 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)
+pprInfixName  n = pprInfixVar (isSymOcc (getOccName n)) (ppr n)
+
+pprPrefixName thing 
+ |  name `hasKey` liftedTypeKindTyConKey 
+ = ppr name   -- See Note [Special treatment for kind *]
+ | otherwise
+ = pprPrefixVar (isSymOcc (nameOccName name)) (ppr name)
+ where
+   name = getName thing
 \end{code}
 
+Note [Special treatment for kind *]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Do not put parens around the kind '*'.  Even though it looks like
+an operator, it is really a special case.
+
+This pprPrefixName stuff is really only used when printing HsSyn,
+which has to be polymorphic in the name type, and hence has to go via
+the overloaded function pprPrefixOcc.  It's easier where we know the
+type being pretty printed; eg the pretty-printing code in TypeRep.
+
+See Trac #7645, which led to this.
+