[project @ 2000-10-12 11:47:25 by sewardj]

Rename a bunch of mkSrc* things into mk*'s.

diff --git a/ghc/compiler/basicTypes/MkId.lhs b/ghc/compiler/basicTypes/MkId.lhs
index d5d2910..c1fe5e5 100644 (file)
--- a/ghc/compiler/basicTypes/MkId.lhs
+++ b/ghc/compiler/basicTypes/MkId.lhs
@@ -60,7 +60,7 @@ import Name           ( mkDerivedName, mkWiredInIdName, mkLocalName,
                          mkWorkerOcc, mkSuperDictSelOcc, mkCCallName,
                          Name, NamedThing(..),
                        )
-import OccName         ( mkSrcVarOcc )
+import OccName         ( mkVarOcc )
 import PrimOp          ( PrimOp(DataToTagOp, CCallOp), 
                          primOpSig, mkPrimOpIdName,
                          CCall, pprCCallOp
@@ -783,7 +783,7 @@ pAR_ERROR_ID
 pcMiscPrelId :: Unique{-IdKey-} -> Module -> FAST_STRING -> Type -> IdInfo -> Id
 pcMiscPrelId key mod str ty info
   = let
-       name = mkWiredInIdName key mod (mkSrcVarOcc str) imp
+       name = mkWiredInIdName key mod (mkVarOcc str) imp
        imp  = mkId name ty info -- the usual case...
     in
     imp

diff --git a/ghc/compiler/basicTypes/Name.lhs b/ghc/compiler/basicTypes/Name.lhs
index ddfae90..dba3c5d 100644 (file)
--- a/ghc/compiler/basicTypes/Name.lhs
+++ b/ghc/compiler/basicTypes/Name.lhs
@@ -130,7 +130,7 @@ mkKnownKeyGlobal rdr_name uniq
 
 mkSysLocalName :: Unique -> UserFS -> Name
 mkSysLocalName uniq fs = Name { n_uniq = uniq, n_sort = Local, 
-                               n_occ = mkSrcVarOcc fs, n_prov = systemProvenance }
+                               n_occ = mkVarOcc fs, n_prov = systemProvenance }
 
 mkCCallName :: Unique -> EncodedString -> Name
        -- The encoded string completely describes the ccall
@@ -150,7 +150,7 @@ mkTopName :: Unique -> Module -> FAST_STRING -> Name
 mkTopName uniq mod fs
   = Name { n_uniq = uniq, 
           n_sort = mk_top_sort mod,
-          n_occ  = mkSrcVarOcc (_PK_ ((_UNPK_ fs) ++ show uniq)),
+          n_occ  = mkVarOcc (_PK_ ((_UNPK_ fs) ++ show uniq)),
           n_prov = LocalDef noSrcLoc NotExported }
 
 mkIPName :: Unique -> OccName -> Name

diff --git a/ghc/compiler/basicTypes/OccName.lhs b/ghc/compiler/basicTypes/OccName.lhs
index 9efd4af..6a1de96 100644 (file)
--- a/ghc/compiler/basicTypes/OccName.lhs
+++ b/ghc/compiler/basicTypes/OccName.lhs
@@ -14,7 +14,7 @@ module OccName (
        OccName,        -- Abstract, instance of Outputable
        pprOccName, 
 
-       mkSrcOccFS, mkSysOcc, mkSysOccFS, mkCCallOcc, mkSrcVarOcc, mkKindOccFS,
+       mkOccFS, mkSysOcc, mkSysOccFS, mkCCallOcc, mkVarOcc, mkKindOccFS,
        mkSuperDictSelOcc, mkDFunOcc, mkForeignExportOcc,
        mkDictOcc, mkIPOcc, mkWorkerOcc, mkMethodOcc, mkDefaultMethodOcc,
        mkDerivedTyConOcc, mkClassTyConOcc, mkClassDataConOcc, mkSpecOcc,
@@ -188,11 +188,11 @@ mkKindOccFS occ_sp fs = OccName occ_sp fs
 *Source-code* things are encoded.
 
 \begin{code}
-mkSrcOccFS :: NameSpace -> UserFS -> OccName
-mkSrcOccFS occ_sp fs = mkSysOccFS occ_sp (encodeFS fs)
+mkOccFS :: NameSpace -> UserFS -> OccName
+mkOccFS occ_sp fs = mkSysOccFS occ_sp (encodeFS fs)
 
-mkSrcVarOcc :: UserFS -> OccName
-mkSrcVarOcc fs = mkSysOccFS varName (encodeFS fs)
+mkVarOcc :: UserFS -> OccName
+mkVarOcc fs = mkSysOccFS varName (encodeFS fs)
 \end{code}
 
 

diff --git a/ghc/compiler/basicTypes/RdrName.lhs b/ghc/compiler/basicTypes/RdrName.lhs
index 4644c79..a438c65 100644 (file)
--- a/ghc/compiler/basicTypes/RdrName.lhs
+++ b/ghc/compiler/basicTypes/RdrName.lhs
@@ -10,7 +10,7 @@ module RdrName (
 
        -- Construction
        mkRdrUnqual, mkRdrQual,
-       mkSrcUnqual, mkSrcQual, 
+       mkUnqual, mkQual, 
        mkSysUnqual, mkSysQual,
        mkPreludeQual, qualifyRdrName, mkRdrNameWkr,
        dummyRdrVarName, dummyRdrTcName,
@@ -33,7 +33,7 @@ module RdrName (
 import OccName ( NameSpace, tcName,
                  OccName, UserFS,
                  mkSysOccFS,
-                 mkSrcOccFS, mkSrcVarOcc,
+                 mkOccFS, mkVarOcc,
                  isDataOcc, isTvOcc, mkWorkerOcc
                )
 import Module   ( ModuleName,
@@ -86,11 +86,11 @@ mkRdrQual mod occ = RdrName (Qual mod) occ
 
        -- These two are used when parsing source files
        -- They do encode the module and occurrence names
-mkSrcUnqual :: NameSpace -> FAST_STRING -> RdrName
-mkSrcUnqual sp n = RdrName Unqual (mkSrcOccFS sp n)
+mkUnqual :: NameSpace -> FAST_STRING -> RdrName
+mkUnqual sp n = RdrName Unqual (mkOccFS sp n)
 
-mkSrcQual :: NameSpace -> (UserFS, UserFS) -> RdrName
-mkSrcQual sp (m, n) = RdrName (Qual (mkModuleNameFS m)) (mkSrcOccFS sp n)
+mkQual :: NameSpace -> (UserFS, UserFS) -> RdrName
+mkQual sp (m, n) = RdrName (Qual (mkModuleNameFS m)) (mkOccFS sp n)
 
        -- These two are used when parsing interface files
        -- They do not encode the module and occurrence name
@@ -101,7 +101,7 @@ mkSysQual :: NameSpace -> (FAST_STRING, FAST_STRING) -> RdrName
 mkSysQual sp (m,n) = RdrName (Qual (mkSysModuleNameFS m)) (mkSysOccFS sp n)
 
 mkPreludeQual :: NameSpace -> ModuleName -> FAST_STRING -> RdrName
-mkPreludeQual sp mod n = RdrName (Qual mod) (mkSrcOccFS sp n)
+mkPreludeQual sp mod n = RdrName (Qual mod) (mkOccFS sp n)
 
 qualifyRdrName :: ModuleName -> RdrName -> RdrName
        -- Sets the module name of a RdrName, even if it has one already
@@ -117,8 +117,8 @@ mkRdrNameWkr (RdrName qual occ) = RdrName qual (mkWorkerOcc occ)
        -- the renamer.  We can't just put "error..." because
        -- we sometimes want to print out stuff after reading but
        -- before renaming
-dummyRdrVarName = RdrName Unqual (mkSrcVarOcc SLIT("V-DUMMY"))
-dummyRdrTcName  = RdrName Unqual (mkSrcOccFS tcName SLIT("TC-DUMMY"))
+dummyRdrVarName = RdrName Unqual (mkVarOcc SLIT("V-DUMMY"))
+dummyRdrTcName  = RdrName Unqual (mkOccFS tcName SLIT("TC-DUMMY"))
 \end{code}
 
 

diff --git a/ghc/compiler/deSugar/Check.lhs b/ghc/compiler/deSugar/Check.lhs
index a86a832..c692b2d 100644 (file)
--- a/ghc/compiler/deSugar/Check.lhs
+++ b/ghc/compiler/deSugar/Check.lhs
@@ -19,7 +19,7 @@ import DsUtils                ( EquationInfo(..), MatchResult(..), EqnSet, CanItFail(..),
 import Id              ( idType )
 import DataCon         ( DataCon, dataConTyCon, dataConArgTys,
                          dataConSourceArity, dataConFieldLabels )
-import Name             ( Name, mkLocalName, getOccName, isDataSymOcc, getName, mkSrcVarOcc )
+import Name             ( Name, mkLocalName, getOccName, isDataSymOcc, getName, mkVarOcc )
 import Type            ( splitAlgTyConApp, mkTyVarTys, splitTyConApp_maybe )
 import TysWiredIn      ( nilDataCon, consDataCon, 
                           mkListTy, mkTupleTy, tupleCon
@@ -373,7 +373,7 @@ make_row_vars used_lits (EqnInfo _ _ pats _ ) =
   where new_var = hash_x
 
 hash_x = mkLocalName unboundKey {- doesn't matter much -}
-                    (mkSrcVarOcc SLIT("#x"))
+                    (mkVarOcc SLIT("#x"))
                     noSrcLoc
 
 make_row_vars_for_constructor :: EquationInfo -> [WarningPat]

diff --git a/ghc/compiler/parser/ParseUtil.lhs b/ghc/compiler/parser/ParseUtil.lhs
index 5f929c6..a80b24b 100644 (file)
--- a/ghc/compiler/parser/ParseUtil.lhs
+++ b/ghc/compiler/parser/ParseUtil.lhs
@@ -335,5 +335,5 @@ groupBindings binds = group Nothing binds
                RdrValBinding b@(FunMonoBind _ _ _ _) -> group (Just b) binds
                other -> bind `RdrAndBindings` group Nothing binds
 
-plus_RDR = mkSrcUnqual varName SLIT("+")
+plus_RDR = mkUnqual varName SLIT("+")
 \end{code}

diff --git a/ghc/compiler/parser/Parser.y b/ghc/compiler/parser/Parser.y
index ecfaf2d..d067c64 100644 (file)
--- a/ghc/compiler/parser/Parser.y
+++ b/ghc/compiler/parser/Parser.y
@@ -1,6 +1,6 @@
 {-
 -----------------------------------------------------------------------------
-$Id: Parser.y,v 1.40 2000/10/06 09:31:45 simonpj Exp $
+$Id: Parser.y,v 1.41 2000/10/12 11:47:26 sewardj Exp $
 
 Haskell grammar.
 
@@ -903,7 +903,7 @@ qvar        :: { RdrName }
 -- *after* we see the close paren.
 
 ipvar  :: { RdrName }
-       : IPVARID               { (mkSrcUnqual ipName (tailFS $1)) }
+       : IPVARID               { (mkUnqual ipName (tailFS $1)) }
 
 qcon   :: { RdrName }
        : qconid                { $1 }
@@ -949,21 +949,21 @@ qopm      :: { RdrNameHsExpr }   -- used in sections
 
 qvarid :: { RdrName }
        : varid                 { $1 }
-       | QVARID                { mkSrcQual varName $1 }
+       | QVARID                { mkQual varName $1 }
 
 varid :: { RdrName }
        : varid_no_unsafe       { $1 }
-       | 'unsafe'              { mkSrcUnqual varName SLIT("unsafe") }
+       | 'unsafe'              { mkUnqual varName SLIT("unsafe") }
 
 varid_no_unsafe :: { RdrName }
-       : VARID                 { mkSrcUnqual varName $1 }
-       | special_id            { mkSrcUnqual varName $1 }
-       | 'forall'              { mkSrcUnqual varName SLIT("forall") }
+       : VARID                 { mkUnqual varName $1 }
+       | special_id            { mkUnqual varName $1 }
+       | 'forall'              { mkUnqual varName SLIT("forall") }
 
 tyvar  :: { RdrName }
-       : VARID                 { mkSrcUnqual tvName $1 }
-       | special_id            { mkSrcUnqual tvName $1 }
-       | 'unsafe'              { mkSrcUnqual tvName SLIT("unsafe") }
+       : VARID                 { mkUnqual tvName $1 }
+       | special_id            { mkUnqual tvName $1 }
+       | 'unsafe'              { mkUnqual tvName SLIT("unsafe") }
 
 -- These special_ids are treated as keywords in various places, 
 -- but as ordinary ids elsewhere.   A special_id collects all thsee
@@ -984,20 +984,20 @@ special_id
 
 qconid :: { RdrName }
        : conid                 { $1 }
-       | QCONID                { mkSrcQual dataName $1 }
+       | QCONID                { mkQual dataName $1 }
 
 conid  :: { RdrName }
-       : CONID                 { mkSrcUnqual dataName $1 }
+       : CONID                 { mkUnqual dataName $1 }
 
 -----------------------------------------------------------------------------
 -- ConSyms
 
 qconsym :: { RdrName }
        : consym                { $1 }
-       | QCONSYM               { mkSrcQual dataName $1 }
+       | QCONSYM               { mkQual dataName $1 }
 
 consym :: { RdrName }
-       : CONSYM                { mkSrcUnqual dataName $1 }
+       : CONSYM                { mkUnqual dataName $1 }
 
 -----------------------------------------------------------------------------
 -- VarSyms
@@ -1011,15 +1011,15 @@ qvarsym_no_minus :: { RdrName }
        | qvarsym1              { $1 }
 
 qvarsym1 :: { RdrName }
-qvarsym1 : QVARSYM             { mkSrcQual varName $1 }
+qvarsym1 : QVARSYM             { mkQual varName $1 }
 
 varsym :: { RdrName }
        : varsym_no_minus       { $1 }
-       | '-'                   { mkSrcUnqual varName SLIT("-") }
+       | '-'                   { mkUnqual varName SLIT("-") }
 
 varsym_no_minus :: { RdrName } -- varsym not including '-'
-       : VARSYM                { mkSrcUnqual varName $1 }
-       | special_sym           { mkSrcUnqual varName $1 }
+       : VARSYM                { mkUnqual varName $1 }
+       | special_sym           { mkUnqual varName $1 }
 
 
 -- See comments with special_id
@@ -1059,18 +1059,18 @@ modid   :: { ModuleName }
        : CONID                 { mkSrcModuleFS $1 }
 
 tycon  :: { RdrName }
-       : CONID                 { mkSrcUnqual tcClsName $1 }
+       : CONID                 { mkUnqual tcClsName $1 }
 
 tyconop        :: { RdrName }
-       : CONSYM                { mkSrcUnqual tcClsName $1 }
+       : CONSYM                { mkUnqual tcClsName $1 }
 
 qtycon :: { RdrName }
        : tycon                 { $1 }
-       | QCONID                { mkSrcQual tcClsName $1 }
+       | QCONID                { mkQual tcClsName $1 }
 
 qtyconop :: { RdrName }
          : tyconop             { $1 }
-         | QCONSYM             { mkSrcQual tcClsName $1 }
+         | QCONSYM             { mkQual tcClsName $1 }
 
 qtycls         :: { RdrName }
        : qtycon                { $1 }

diff --git a/ghc/compiler/parser/RdrHsSyn.lhs b/ghc/compiler/parser/RdrHsSyn.lhs
index 5af43d6..3c3e1ef 100644 (file)
--- a/ghc/compiler/parser/RdrHsSyn.lhs
+++ b/ghc/compiler/parser/RdrHsSyn.lhs
@@ -82,7 +82,7 @@ import OccName                ( mkClassTyConOcc, mkClassDataConOcc, mkWorkerOcc,
                        )
 import PrelNames       ( pRELUDE_Name, mkTupNameStr )
 import RdrName         ( RdrName, isRdrTyVar, mkRdrUnqual, rdrNameOcc,
-                         mkSrcUnqual, mkPreludeQual
+                         mkUnqual, mkPreludeQual
                        )
 import HsPragmas       
 import List            ( nub )
@@ -336,7 +336,7 @@ tupleTyCon_RDR arity    = prelQual tcName   (snd (mkTupNameStr Boxed arity))
 ubxTupleCon_RDR arity   = prelQual dataName (snd (mkTupNameStr Unboxed arity))
 ubxTupleTyCon_RDR arity = prelQual tcName   (snd (mkTupNameStr Unboxed arity))
 
-prelQual ns occ | opt_NoImplicitPrelude = mkSrcUnqual   ns occ
+prelQual ns occ | opt_NoImplicitPrelude = mkUnqual   ns occ
                | otherwise             = mkPreludeQual ns pRELUDE_Name occ
 \end{code}
 

diff --git a/ghc/compiler/prelude/PrimOp.lhs b/ghc/compiler/prelude/PrimOp.lhs
index 5d97207..7ebb079 100644 (file)
--- a/ghc/compiler/prelude/PrimOp.lhs
+++ b/ghc/compiler/prelude/PrimOp.lhs
@@ -34,7 +34,7 @@ import Var            ( TyVar, Id )
 import CallConv                ( CallConv, pprCallConv )
 import Name            ( Name, mkWiredInIdName )
 import RdrName         ( RdrName, mkRdrQual )
-import OccName         ( OccName, pprOccName, mkSrcVarOcc )
+import OccName         ( OccName, pprOccName, mkVarOcc )
 import TyCon           ( TyCon, tyConArity )
 import Type            ( Type, mkForAllTys, mkFunTy, mkFunTys, mkTyVarTys,
                          mkTyConApp, typePrimRep,
@@ -134,10 +134,10 @@ data PrimOpInfo
                [Type] 
                Type 
 
-mkDyadic str  ty = Dyadic  (mkSrcVarOcc str) ty
-mkMonadic str ty = Monadic (mkSrcVarOcc str) ty
-mkCompare str ty = Compare (mkSrcVarOcc str) ty
-mkGenPrimOp str tvs tys ty = GenPrimOp (mkSrcVarOcc str) tvs tys ty
+mkDyadic str  ty = Dyadic  (mkVarOcc str) ty
+mkMonadic str ty = Monadic (mkVarOcc str) ty
+mkCompare str ty = Compare (mkVarOcc str) ty
+mkGenPrimOp str tvs tys ty = GenPrimOp (mkVarOcc str) tvs tys ty
 \end{code}
 
 %************************************************************************

diff --git a/ghc/compiler/prelude/TysWiredIn.lhs b/ghc/compiler/prelude/TysWiredIn.lhs
index 91c068d..afd537f 100644 (file)
--- a/ghc/compiler/prelude/TysWiredIn.lhs
+++ b/ghc/compiler/prelude/TysWiredIn.lhs
@@ -93,7 +93,7 @@ import TysPrim
 import Constants       ( mAX_TUPLE_SIZE )
 import Module          ( Module, mkPrelModule )
 import Name            ( mkWiredInTyConName, mkWiredInIdName, nameOccName )
-import OccName         ( mkSrcOccFS, tcName, dataName, mkWorkerOcc, mkGenOcc1, mkGenOcc2 )
+import OccName         ( mkOccFS, tcName, dataName, mkWorkerOcc, mkGenOcc1, mkGenOcc2 )
 import RdrName         ( RdrName, mkPreludeQual, rdrNameOcc, rdrNameModule )
 import DataCon         ( DataCon, StrictnessMark(..),  mkDataCon, dataConId )
 import Var             ( TyVar, tyVarKind )
@@ -236,7 +236,7 @@ mk_tuple :: Boxity -> Int -> (TyCon,DataCon)
 mk_tuple boxity arity = (tycon, tuple_con)
   where
        tycon   = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info 
-       tc_name = mkWiredInTyConName tc_uniq mod (mkSrcOccFS tcName name_str) tycon
+       tc_name = mkWiredInTyConName tc_uniq mod (mkOccFS tcName name_str) tycon
        tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
        res_kind | isBoxed boxity = boxedTypeKind
                 | otherwise      = unboxedTypeKind

diff --git a/ghc/compiler/typecheck/TcGenDeriv.lhs b/ghc/compiler/typecheck/TcGenDeriv.lhs
index 8798f09..b073070 100644 (file)
--- a/ghc/compiler/typecheck/TcGenDeriv.lhs
+++ b/ghc/compiler/typecheck/TcGenDeriv.lhs
@@ -32,7 +32,7 @@ import HsSyn          ( InPat(..), HsExpr(..), MonoBinds(..),
                          unguardedRHS, mkSimpleMatch, mkMonoBind, andMonoBindList
                        )
 import RdrHsSyn                ( mkHsOpApp, RdrNameMonoBinds, RdrNameHsExpr, RdrNamePat )
-import RdrName         ( RdrName, mkSrcUnqual )
+import RdrName         ( RdrName, mkUnqual )
 import RnMonad         ( FixityEnv, lookupFixity )
 import BasicTypes      ( RecFlag(..), Fixity(..), FixityDirection(..)
                        , maxPrecedence
@@ -1355,7 +1355,7 @@ genOpApp e1 op e2 = mkHsOpApp e1 op e2
 
 \begin{code}
 qual_orig_name n = nameRdrName (getName n)
-varUnqual n      = mkSrcUnqual varName n
+varUnqual n      = mkUnqual varName n
 
 zz_a_RDR       = varUnqual SLIT("_a")
 a_RDR          = varUnqual SLIT("a")

diff --git a/ghc/compiler/types/TypeRep.lhs b/ghc/compiler/types/TypeRep.lhs
index 6e29873..98cca95 100644 (file)
--- a/ghc/compiler/types/TypeRep.lhs
+++ b/ghc/compiler/types/TypeRep.lhs
@@ -30,7 +30,7 @@ import VarSet
 import Name    ( Name, Provenance(..), ExportFlag(..),
                  mkWiredInTyConName, mkGlobalName, mkKindOccFS, tcName,
                )
-import OccName ( mkSrcOccFS, tcName )
+import OccName ( mkOccFS, tcName )
 import TyCon   ( TyCon, KindCon,
                  mkFunTyCon, mkKindCon, mkSuperKindCon,
                )
@@ -298,7 +298,7 @@ mkArrowKinds arg_kinds result_kind = foldr mkArrowKind result_kind arg_kinds
 We define a few wired-in type constructors here to avoid module knots
 
 \begin{code}
-funTyConName = mkWiredInTyConName funTyConKey pREL_GHC (mkSrcOccFS tcName SLIT("(->)")) funTyCon
+funTyConName = mkWiredInTyConName funTyConKey pREL_GHC (mkOccFS tcName SLIT("(->)")) funTyCon
 funTyCon = mkFunTyCon funTyConName (mkArrowKinds [boxedTypeKind, boxedTypeKind] boxedTypeKind)
 \end{code}