X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fprelude%2FPrelNames.lhs;h=59a13de421e181998f6ee4a62221170ff423bef7;hp=c324e95151b2dab8fda8753540236614955f1c3b;hb=e5c3b478b3cd1707cf122833822f44b2ac09b8e9;hpb=fcf6b22d0478be20e27c2245f3e34dd272e12522 diff --git a/compiler/prelude/PrelNames.lhs b/compiler/prelude/PrelNames.lhs index c324e95..59a13de 100644 --- a/compiler/prelude/PrelNames.lhs +++ b/compiler/prelude/PrelNames.lhs @@ -6,43 +6,36 @@ Nota Bene: all Names defined in here should come from the base package -* ModuleNames for prelude modules, + - ModuleNames for prelude modules, e.g. pREL_BASE_Name :: ModuleName -* Modules for prelude modules + - Modules for prelude modules e.g. pREL_Base :: Module -* Uniques for Ids, DataCons, TyCons and Classes that the compiler - "knows about" in some way + - Uniques for Ids, DataCons, TyCons and Classes that the compiler + "knows about" in some way e.g. intTyConKey :: Unique minusClassOpKey :: Unique -* Names for Ids, DataCons, TyCons and Classes that the compiler - "knows about" in some way + - Names for Ids, DataCons, TyCons and Classes that the compiler + "knows about" in some way e.g. intTyConName :: Name minusName :: Name - One of these Names contains + One of these Names contains (a) the module and occurrence name of the thing (b) its Unique - The may way the compiler "knows about" one of these things is - where the type checker or desugarer needs to look it up. For - example, when desugaring list comprehensions the desugarer - needs to conjure up 'foldr'. It does this by looking up - foldrName in the environment. + The may way the compiler "knows about" one of these things is + where the type checker or desugarer needs to look it up. For + example, when desugaring list comprehensions the desugarer + needs to conjure up 'foldr'. It does this by looking up + foldrName in the environment. -* RdrNames for Ids, DataCons etc that the compiler may emit into - generated code (e.g. for deriving). It's not necessary to know - the uniques for these guys, only their names + - RdrNames for Ids, DataCons etc that the compiler may emit into + generated code (e.g. for deriving). It's not necessary to know + the uniques for these guys, only their names \begin{code} -{-# OPTIONS -w #-} --- The above warning supression flag is a temporary kludge. --- While working on this module you are encouraged to remove it and fix --- any warnings in the module. See --- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings --- for details - module PrelNames ( Unique, Uniquable(..), hasKey, -- Re-exported for convenience @@ -57,8 +50,7 @@ module PrelNames ( #include "HsVersions.h" import Module -import OccName ( dataName, tcName, clsName, varName, tvName, - mkOccNameFS, mkVarOccFS ) +import OccName import RdrName ( RdrName, nameRdrName, mkOrig, rdrNameOcc, mkUnqual ) import Unique ( Unique, Uniquable(..), hasKey, mkPreludeMiscIdUnique, mkPreludeDataConUnique, @@ -66,7 +58,7 @@ import Unique ( Unique, Uniquable(..), hasKey, mkTupleTyConUnique ) import BasicTypes ( Boxity(..), Arity ) -import Name ( Name, mkInternalName, mkExternalName ) +import Name ( Name, mkInternalName, mkExternalName, mkSystemVarName ) import SrcLoc import FastString \end{code} @@ -81,7 +73,8 @@ import FastString This *local* name is used by the interactive stuff \begin{code} -itName uniq = mkInternalName uniq (mkOccNameFS varName FSLIT("it")) noSrcSpan +itName :: Unique -> Name +itName uniq = mkInternalName uniq (mkOccNameFS varName (fsLit "it")) noSrcSpan \end{code} \begin{code} @@ -96,20 +89,27 @@ isUnboundName name = name `hasKey` unboundKey %************************************************************************ -%* * +%* * \subsection{Known key Names} -%* * +%* * %************************************************************************ -This section tells what the compiler knows about the assocation of +This section tells what the compiler knows about the association of names with uniques. These ones are the *non* wired-in ones. The wired in ones are defined in TysWiredIn etc. +The names for DPH can come from one of multiple backend packages. At the point where +'basicKnownKeyNames' is used, we don't know which backend it will be. Hence, we list +the names for multiple backends. That works out fine, although they use the same uniques, +as we are guaranteed to only load one backend; hence, only one of the different names +sharing a unique will be used. + \begin{code} basicKnownKeyNames :: [Name] basicKnownKeyNames = genericTyConNames ++ typeableClassNames + ++ dphKnownKeyNames dphSeqPackageId ++ dphKnownKeyNames dphParPackageId ++ [ -- Type constructors (synonyms especially) ioTyConName, ioDataConName, runMainIOName, @@ -138,11 +138,17 @@ basicKnownKeyNames realFloatClassName, -- numeric dataClassName, isStringClassName, + applicativeClassName, + foldableClassName, + traversableClassName, -- Numeric stuff - negateName, minusName, - fromRationalName, fromIntegerName, - geName, eqName, + negateName, minusName, geName, eqName, + + -- Conversion functions + fromRationalName, fromIntegerName, + toIntegerName, toRationalName, + fromIntegralName, realToFracName, -- String stuff fromStringName, @@ -150,11 +156,11 @@ basicKnownKeyNames -- Enum stuff enumFromName, enumFromThenName, enumFromThenToName, enumFromToName, - enumFromToPName, enumFromThenToPName, -- Monad stuff thenIOName, bindIOName, returnIOName, failIOName, failMName, bindMName, thenMName, returnMName, + fmapName, -- MonadRec stuff mfixName, @@ -171,12 +177,12 @@ basicKnownKeyNames -- Read stuff readClassName, - + -- Stable pointers newStablePtrName, -- GHC Extensions - groupWithName, + groupWithName, -- Strings and lists unpackCStringName, unpackCStringAppendName, @@ -186,10 +192,7 @@ basicKnownKeyNames concatName, filterName, mapName, zipName, foldrName, buildName, augmentName, appendName, - -- Parallel array operations - nullPName, lengthPName, replicatePName, singletonPName, mapPName, - filterPName, zipPName, crossMapPName, indexPName, - toPName, bpermutePName, bpermuteDftPName, indexOfPName, + dollarName, -- The ($) apply function -- FFI primitive types that are not wired-in. stablePtrTyConName, ptrTyConName, funPtrTyConName, @@ -210,19 +213,55 @@ basicKnownKeyNames -- Other classes randomClassName, randomGenClassName, monadPlusClassName, - -- Booleans - andName, orName - + -- Code types + hetmet_brak_name, hetmet_esc_name, hetmet_csp_name, + hetmet_kappa_name, hetmet_kappa_app_name, + hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name, hetmet_guest_char_literal_name, + + -- Annotation type checking + toAnnotationWrapperName + -- The Either type , eitherTyConName, leftDataConName, rightDataConName -- dotnet interop , objectTyConName, marshalObjectName, unmarshalObjectName , marshalStringName, unmarshalStringName, checkDotnetResName + + -- Generics + , genClassName, gen1ClassName + , datatypeClassName, constructorClassName, selectorClassName + + -- Monad comprehensions + , guardMName + , liftMName + , groupMName + , mzipName ] genericTyConNames :: [Name] -genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName] +genericTyConNames = [ + v1TyConName, u1TyConName, par1TyConName, rec1TyConName, + k1TyConName, m1TyConName, sumTyConName, prodTyConName, + compTyConName, rTyConName, pTyConName, dTyConName, + cTyConName, sTyConName, rec0TyConName, par0TyConName, + d1TyConName, c1TyConName, s1TyConName, noSelTyConName, + repTyConName, rep1TyConName + ] + +-- Know names from the DPH package which vary depending on the selected DPH backend. +-- +dphKnownKeyNames :: PackageId -> [Name] +dphKnownKeyNames dphPkg + = map ($ dphPkg) + [ + -- Parallel array operations + nullPName, lengthPName, replicatePName, singletonPName, mapPName, + filterPName, zipPName, crossMapPName, indexPName, + toPName, emptyPName, appPName, + enumFromToPName, enumFromThenToPName + + ] \end{code} @@ -235,61 +274,101 @@ genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName] --MetaHaskell Extension Add a new module here \begin{code} +pRELUDE :: Module pRELUDE = mkBaseModule_ pRELUDE_NAME -gHC_PRIM = mkPrimModule FSLIT("GHC.Prim") -- Primitive types and values -gHC_BOOL = mkPrimModule FSLIT("GHC.Bool") -gHC_GENERICS = mkPrimModule FSLIT("GHC.Generics") -gHC_BASE = mkBaseModule FSLIT("GHC.Base") -gHC_ENUM = mkBaseModule FSLIT("GHC.Enum") -gHC_SHOW = mkBaseModule FSLIT("GHC.Show") -gHC_READ = mkBaseModule FSLIT("GHC.Read") -gHC_NUM = mkBaseModule FSLIT("GHC.Num") -gHC_INTEGER = mkIntegerModule FSLIT("GHC.Integer") -gHC_LIST = mkBaseModule FSLIT("GHC.List") -gHC_PARR = mkBaseModule FSLIT("GHC.PArr") -dATA_TUP = mkBaseModule FSLIT("Data.Tuple") -dATA_EITHER = mkBaseModule FSLIT("Data.Either") -dATA_STRING = mkBaseModule FSLIT("Data.String") -gHC_PACK = mkBaseModule FSLIT("GHC.Pack") -gHC_CONC = mkBaseModule FSLIT("GHC.Conc") -gHC_IO_BASE = mkBaseModule FSLIT("GHC.IOBase") -gHC_ST = mkBaseModule FSLIT("GHC.ST") -gHC_ARR = mkBaseModule FSLIT("GHC.Arr") -gHC_STABLE = mkBaseModule FSLIT("GHC.Stable") -gHC_ADDR = mkBaseModule FSLIT("GHC.Addr") -gHC_PTR = mkBaseModule FSLIT("GHC.Ptr") -gHC_ERR = mkBaseModule FSLIT("GHC.Err") -gHC_REAL = mkBaseModule FSLIT("GHC.Real") -gHC_FLOAT = mkBaseModule FSLIT("GHC.Float") -gHC_TOP_HANDLER = mkBaseModule FSLIT("GHC.TopHandler") -sYSTEM_IO = mkBaseModule FSLIT("System.IO") -dYNAMIC = mkBaseModule FSLIT("Data.Dynamic") -tYPEABLE = mkBaseModule FSLIT("Data.Typeable") -gENERICS = mkBaseModule FSLIT("Data.Generics.Basics") -dOTNET = mkBaseModule FSLIT("GHC.Dotnet") -rEAD_PREC = mkBaseModule FSLIT("Text.ParserCombinators.ReadPrec") -lEX = mkBaseModule FSLIT("Text.Read.Lex") -gHC_INT = mkBaseModule FSLIT("GHC.Int") -gHC_WORD = mkBaseModule FSLIT("GHC.Word") -mONAD = mkBaseModule FSLIT("Control.Monad") -mONAD_FIX = mkBaseModule FSLIT("Control.Monad.Fix") -aRROW = mkBaseModule FSLIT("Control.Arrow") -gHC_DESUGAR = mkBaseModule FSLIT("GHC.Desugar") -rANDOM = mkBaseModule FSLIT("System.Random") -gHC_EXTS = mkBaseModule FSLIT("GHC.Exts") +gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS, + gHC_MAGIC, + gHC_CLASSES, gHC_BASE, gHC_ENUM, gHC_CSTRING, + gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST, + gHC_HETMET_CODETYPES, + gHC_HETMET_PRIVATE, + gHC_HETMET_GARROW, + gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE, + gHC_CONC, gHC_IO, gHC_IO_Exception, + gHC_ST, gHC_ARR, gHC_STABLE, gHC_PTR, gHC_ERR, gHC_REAL, + gHC_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS, + dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, mONAD_GROUP, mONAD_ZIP, + aRROW, cONTROL_APPLICATIVE, gHC_DESUGAR, rANDOM, gHC_EXTS, + cONTROL_EXCEPTION_BASE :: Module + +gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values +gHC_TYPES = mkPrimModule (fsLit "GHC.Types") +gHC_UNIT = mkPrimModule (fsLit "GHC.Unit") +gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering") +gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics") +gHC_MAGIC = mkPrimModule (fsLit "GHC.Magic") +gHC_CSTRING = mkPrimModule (fsLit "GHC.CString") + +gHC_CLASSES = mkBaseModule (fsLit "GHC.Classes") +gHC_BASE = mkBaseModule (fsLit "GHC.Base") +gHC_ENUM = mkBaseModule (fsLit "GHC.Enum") +gHC_SHOW = mkBaseModule (fsLit "GHC.Show") +gHC_READ = mkBaseModule (fsLit "GHC.Read") +gHC_NUM = mkBaseModule (fsLit "GHC.Num") +gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer") +gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type") +gHC_HETMET_CODETYPES = mkBaseModule (fsLit "GHC.HetMet.CodeTypes") +gHC_HETMET_PRIVATE = mkBaseModule (fsLit "GHC.HetMet.Private") +gHC_HETMET_GARROW = mkBaseModule (fsLit "Control.GArrow") +gHC_LIST = mkBaseModule (fsLit "GHC.List") +gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple") +dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple") +dATA_EITHER = mkBaseModule (fsLit "Data.Either") +dATA_STRING = mkBaseModule (fsLit "Data.String") +dATA_FOLDABLE = mkBaseModule (fsLit "Data.Foldable") +dATA_TRAVERSABLE= mkBaseModule (fsLit "Data.Traversable") +gHC_CONC = mkBaseModule (fsLit "GHC.Conc") +gHC_IO = mkBaseModule (fsLit "GHC.IO") +gHC_IO_Exception = mkBaseModule (fsLit "GHC.IO.Exception") +gHC_ST = mkBaseModule (fsLit "GHC.ST") +gHC_ARR = mkBaseModule (fsLit "GHC.Arr") +gHC_STABLE = mkBaseModule (fsLit "GHC.Stable") +gHC_PTR = mkBaseModule (fsLit "GHC.Ptr") +gHC_ERR = mkBaseModule (fsLit "GHC.Err") +gHC_REAL = mkBaseModule (fsLit "GHC.Real") +gHC_FLOAT = mkBaseModule (fsLit "GHC.Float") +gHC_TOP_HANDLER = mkBaseModule (fsLit "GHC.TopHandler") +sYSTEM_IO = mkBaseModule (fsLit "System.IO") +dYNAMIC = mkBaseModule (fsLit "Data.Dynamic") +tYPEABLE = mkBaseModule (fsLit "Data.Typeable") +gENERICS = mkBaseModule (fsLit "Data.Data") +dOTNET = mkBaseModule (fsLit "GHC.Dotnet") +rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec") +lEX = mkBaseModule (fsLit "Text.Read.Lex") +gHC_INT = mkBaseModule (fsLit "GHC.Int") +gHC_WORD = mkBaseModule (fsLit "GHC.Word") +mONAD = mkBaseModule (fsLit "Control.Monad") +mONAD_FIX = mkBaseModule (fsLit "Control.Monad.Fix") +mONAD_GROUP = mkBaseModule (fsLit "Control.Monad.Group") +mONAD_ZIP = mkBaseModule (fsLit "Control.Monad.Zip") +aRROW = mkBaseModule (fsLit "Control.Arrow") +cONTROL_APPLICATIVE = mkBaseModule (fsLit "Control.Applicative") +gHC_DESUGAR = mkBaseModule (fsLit "GHC.Desugar") +rANDOM = mkBaseModule (fsLit "System.Random") +gHC_EXTS = mkBaseModule (fsLit "GHC.Exts") +cONTROL_EXCEPTION_BASE = mkBaseModule (fsLit "Control.Exception.Base") + +gHC_PARR :: PackageId -> Module +gHC_PARR pkg = mkModule pkg (mkModuleNameFS (fsLit "Data.Array.Parallel")) + +gHC_PARR' :: Module +gHC_PARR' = mkBaseModule (fsLit "GHC.PArr") + +mAIN, rOOT_MAIN :: Module mAIN = mkMainModule_ mAIN_NAME -rOOT_MAIN = mkMainModule FSLIT(":Main") -- Root module for initialisation +rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation -- The ':xxx' makes a module name that the user can never -- use himself. The z-encoding for ':' is "ZC", so the z-encoded -- module name still starts with a capital letter, which keeps -- the z-encoded version consistent. -iNTERACTIVE = mkMainModule FSLIT(":Interactive") -thFAKE = mkMainModule FSLIT(":THFake") +iNTERACTIVE :: Module +iNTERACTIVE = mkMainModule (fsLit ":Interactive") -pRELUDE_NAME = mkModuleNameFS FSLIT("Prelude") -mAIN_NAME = mkModuleNameFS FSLIT("Main") +pRELUDE_NAME, mAIN_NAME :: ModuleName +pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude") +mAIN_NAME = mkModuleNameFS (fsLit "Main") mkPrimModule :: FastString -> Module mkPrimModule m = mkModule primPackageId (mkModuleNameFS m) @@ -318,8 +397,8 @@ mkMainModule_ m = mkModule mainPackageId m \begin{code} mkTupleModule :: Boxity -> Arity -> Module -mkTupleModule Boxed 0 = gHC_BASE -mkTupleModule Boxed _ = dATA_TUP +mkTupleModule Boxed 0 = gHC_UNIT +mkTupleModule Boxed _ = gHC_TUPLE mkTupleModule Unboxed _ = gHC_PRIM \end{code} @@ -331,129 +410,215 @@ mkTupleModule Unboxed _ = gHC_PRIM %************************************************************************ \begin{code} -main_RDR_Unqual = mkUnqual varName FSLIT("main") +main_RDR_Unqual :: RdrName +main_RDR_Unqual = mkUnqual varName (fsLit "main") -- We definitely don't want an Orig RdrName, because -- main might, in principle, be imported into module Main forall_tv_RDR, dot_tv_RDR :: RdrName -forall_tv_RDR = mkUnqual tvName FSLIT("forall") -dot_tv_RDR = mkUnqual tvName FSLIT(".") +forall_tv_RDR = mkUnqual tvName (fsLit "forall") +dot_tv_RDR = mkUnqual tvName (fsLit ".") +eq_RDR, ge_RDR, ne_RDR, le_RDR, lt_RDR, gt_RDR, compare_RDR, + ltTag_RDR, eqTag_RDR, gtTag_RDR :: RdrName eq_RDR = nameRdrName eqName ge_RDR = nameRdrName geName -ne_RDR = varQual_RDR gHC_BASE FSLIT("/=") -le_RDR = varQual_RDR gHC_BASE FSLIT("<=") -lt_RDR = varQual_RDR gHC_BASE FSLIT("<") -gt_RDR = varQual_RDR gHC_BASE FSLIT(">") -compare_RDR = varQual_RDR gHC_BASE FSLIT("compare") -ltTag_RDR = dataQual_RDR gHC_BASE FSLIT("LT") -eqTag_RDR = dataQual_RDR gHC_BASE FSLIT("EQ") -gtTag_RDR = dataQual_RDR gHC_BASE FSLIT("GT") - +ne_RDR = varQual_RDR gHC_CLASSES (fsLit "/=") +le_RDR = varQual_RDR gHC_CLASSES (fsLit "<=") +lt_RDR = varQual_RDR gHC_CLASSES (fsLit "<") +gt_RDR = varQual_RDR gHC_CLASSES (fsLit ">") +compare_RDR = varQual_RDR gHC_CLASSES (fsLit "compare") +ltTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "LT") +eqTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "EQ") +gtTag_RDR = dataQual_RDR gHC_ORDERING (fsLit "GT") + +eqClass_RDR, numClass_RDR, ordClass_RDR, enumClass_RDR, monadClass_RDR + :: RdrName eqClass_RDR = nameRdrName eqClassName numClass_RDR = nameRdrName numClassName ordClass_RDR = nameRdrName ordClassName enumClass_RDR = nameRdrName enumClassName monadClass_RDR = nameRdrName monadClassName -map_RDR = varQual_RDR gHC_BASE FSLIT("map") -append_RDR = varQual_RDR gHC_BASE FSLIT("++") +map_RDR, append_RDR :: RdrName +map_RDR = varQual_RDR gHC_BASE (fsLit "map") +append_RDR = varQual_RDR gHC_BASE (fsLit "++") +foldr_RDR, build_RDR, returnM_RDR, bindM_RDR, failM_RDR :: RdrName foldr_RDR = nameRdrName foldrName build_RDR = nameRdrName buildName returnM_RDR = nameRdrName returnMName bindM_RDR = nameRdrName bindMName failM_RDR = nameRdrName failMName -and_RDR = nameRdrName andName - +left_RDR, right_RDR :: RdrName left_RDR = nameRdrName leftDataConName right_RDR = nameRdrName rightDataConName -fromEnum_RDR = varQual_RDR gHC_ENUM FSLIT("fromEnum") -toEnum_RDR = varQual_RDR gHC_ENUM FSLIT("toEnum") +fromEnum_RDR, toEnum_RDR :: RdrName +fromEnum_RDR = varQual_RDR gHC_ENUM (fsLit "fromEnum") +toEnum_RDR = varQual_RDR gHC_ENUM (fsLit "toEnum") +enumFrom_RDR, enumFromTo_RDR, enumFromThen_RDR, enumFromThenTo_RDR :: RdrName enumFrom_RDR = nameRdrName enumFromName enumFromTo_RDR = nameRdrName enumFromToName enumFromThen_RDR = nameRdrName enumFromThenName enumFromThenTo_RDR = nameRdrName enumFromThenToName +ratioDataCon_RDR, plusInteger_RDR, timesInteger_RDR :: RdrName ratioDataCon_RDR = nameRdrName ratioDataConName plusInteger_RDR = nameRdrName plusIntegerName timesInteger_RDR = nameRdrName timesIntegerName +ioDataCon_RDR :: RdrName ioDataCon_RDR = nameRdrName ioDataConName +eqString_RDR, unpackCString_RDR, unpackCStringFoldr_RDR, + unpackCStringUtf8_RDR :: RdrName eqString_RDR = nameRdrName eqStringName unpackCString_RDR = nameRdrName unpackCStringName unpackCStringFoldr_RDR = nameRdrName unpackCStringFoldrName unpackCStringUtf8_RDR = nameRdrName unpackCStringUtf8Name +newStablePtr_RDR, wordDataCon_RDR :: RdrName newStablePtr_RDR = nameRdrName newStablePtrName -wordDataCon_RDR = dataQual_RDR gHC_WORD FSLIT("W#") +wordDataCon_RDR = dataQual_RDR gHC_WORD (fsLit "W#") +bindIO_RDR, returnIO_RDR :: RdrName bindIO_RDR = nameRdrName bindIOName returnIO_RDR = nameRdrName returnIOName +fromInteger_RDR, fromRational_RDR, minus_RDR, times_RDR, plus_RDR :: RdrName fromInteger_RDR = nameRdrName fromIntegerName fromRational_RDR = nameRdrName fromRationalName minus_RDR = nameRdrName minusName -times_RDR = varQual_RDR gHC_NUM FSLIT("*") -plus_RDR = varQual_RDR gHC_NUM FSLIT("+") +times_RDR = varQual_RDR gHC_NUM (fsLit "*") +plus_RDR = varQual_RDR gHC_NUM (fsLit "+") +fromString_RDR :: RdrName fromString_RDR = nameRdrName fromStringName -compose_RDR = varQual_RDR gHC_BASE FSLIT(".") - -not_RDR = varQual_RDR gHC_BASE FSLIT("not") -getTag_RDR = varQual_RDR gHC_BASE FSLIT("getTag") -succ_RDR = varQual_RDR gHC_ENUM FSLIT("succ") -pred_RDR = varQual_RDR gHC_ENUM FSLIT("pred") -minBound_RDR = varQual_RDR gHC_ENUM FSLIT("minBound") -maxBound_RDR = varQual_RDR gHC_ENUM FSLIT("maxBound") -range_RDR = varQual_RDR gHC_ARR FSLIT("range") -inRange_RDR = varQual_RDR gHC_ARR FSLIT("inRange") -index_RDR = varQual_RDR gHC_ARR FSLIT("index") -unsafeIndex_RDR = varQual_RDR gHC_ARR FSLIT("unsafeIndex") -unsafeRangeSize_RDR = varQual_RDR gHC_ARR FSLIT("unsafeRangeSize") - -readList_RDR = varQual_RDR gHC_READ FSLIT("readList") -readListDefault_RDR = varQual_RDR gHC_READ FSLIT("readListDefault") -readListPrec_RDR = varQual_RDR gHC_READ FSLIT("readListPrec") -readListPrecDefault_RDR = varQual_RDR gHC_READ FSLIT("readListPrecDefault") -readPrec_RDR = varQual_RDR gHC_READ FSLIT("readPrec") -parens_RDR = varQual_RDR gHC_READ FSLIT("parens") -choose_RDR = varQual_RDR gHC_READ FSLIT("choose") -lexP_RDR = varQual_RDR gHC_READ FSLIT("lexP") - -punc_RDR = dataQual_RDR lEX FSLIT("Punc") -ident_RDR = dataQual_RDR lEX FSLIT("Ident") -symbol_RDR = dataQual_RDR lEX FSLIT("Symbol") - -step_RDR = varQual_RDR rEAD_PREC FSLIT("step") -alt_RDR = varQual_RDR rEAD_PREC FSLIT("+++") -reset_RDR = varQual_RDR rEAD_PREC FSLIT("reset") -prec_RDR = varQual_RDR rEAD_PREC FSLIT("prec") - -showList_RDR = varQual_RDR gHC_SHOW FSLIT("showList") -showList___RDR = varQual_RDR gHC_SHOW FSLIT("showList__") -showsPrec_RDR = varQual_RDR gHC_SHOW FSLIT("showsPrec") -showString_RDR = varQual_RDR gHC_SHOW FSLIT("showString") -showSpace_RDR = varQual_RDR gHC_SHOW FSLIT("showSpace") -showParen_RDR = varQual_RDR gHC_SHOW FSLIT("showParen") - -typeOf_RDR = varQual_RDR tYPEABLE FSLIT("typeOf") -mkTypeRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyConApp") -mkTyConRep_RDR = varQual_RDR tYPEABLE FSLIT("mkTyCon") - -undefined_RDR = varQual_RDR gHC_ERR FSLIT("undefined") - -crossDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT(":*:") -inlDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Inl") -inrDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Inr") -genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS FSLIT("Unit") +compose_RDR :: RdrName +compose_RDR = varQual_RDR gHC_BASE (fsLit ".") + +not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR, + and_RDR, range_RDR, inRange_RDR, index_RDR, + unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName +and_RDR = varQual_RDR gHC_CLASSES (fsLit "&&") +not_RDR = varQual_RDR gHC_CLASSES (fsLit "not") +getTag_RDR = varQual_RDR gHC_BASE (fsLit "getTag") +succ_RDR = varQual_RDR gHC_ENUM (fsLit "succ") +pred_RDR = varQual_RDR gHC_ENUM (fsLit "pred") +minBound_RDR = varQual_RDR gHC_ENUM (fsLit "minBound") +maxBound_RDR = varQual_RDR gHC_ENUM (fsLit "maxBound") +range_RDR = varQual_RDR gHC_ARR (fsLit "range") +inRange_RDR = varQual_RDR gHC_ARR (fsLit "inRange") +index_RDR = varQual_RDR gHC_ARR (fsLit "index") +unsafeIndex_RDR = varQual_RDR gHC_ARR (fsLit "unsafeIndex") +unsafeRangeSize_RDR = varQual_RDR gHC_ARR (fsLit "unsafeRangeSize") + +readList_RDR, readListDefault_RDR, readListPrec_RDR, readListPrecDefault_RDR, + readPrec_RDR, parens_RDR, choose_RDR, lexP_RDR :: RdrName +readList_RDR = varQual_RDR gHC_READ (fsLit "readList") +readListDefault_RDR = varQual_RDR gHC_READ (fsLit "readListDefault") +readListPrec_RDR = varQual_RDR gHC_READ (fsLit "readListPrec") +readListPrecDefault_RDR = varQual_RDR gHC_READ (fsLit "readListPrecDefault") +readPrec_RDR = varQual_RDR gHC_READ (fsLit "readPrec") +parens_RDR = varQual_RDR gHC_READ (fsLit "parens") +choose_RDR = varQual_RDR gHC_READ (fsLit "choose") +lexP_RDR = varQual_RDR gHC_READ (fsLit "lexP") + +punc_RDR, ident_RDR, symbol_RDR :: RdrName +punc_RDR = dataQual_RDR lEX (fsLit "Punc") +ident_RDR = dataQual_RDR lEX (fsLit "Ident") +symbol_RDR = dataQual_RDR lEX (fsLit "Symbol") + +step_RDR, alt_RDR, reset_RDR, prec_RDR :: RdrName +step_RDR = varQual_RDR rEAD_PREC (fsLit "step") +alt_RDR = varQual_RDR rEAD_PREC (fsLit "+++") +reset_RDR = varQual_RDR rEAD_PREC (fsLit "reset") +prec_RDR = varQual_RDR rEAD_PREC (fsLit "prec") + +showList_RDR, showList___RDR, showsPrec_RDR, showString_RDR, + showSpace_RDR, showParen_RDR :: RdrName +showList_RDR = varQual_RDR gHC_SHOW (fsLit "showList") +showList___RDR = varQual_RDR gHC_SHOW (fsLit "showList__") +showsPrec_RDR = varQual_RDR gHC_SHOW (fsLit "showsPrec") +showString_RDR = varQual_RDR gHC_SHOW (fsLit "showString") +showSpace_RDR = varQual_RDR gHC_SHOW (fsLit "showSpace") +showParen_RDR = varQual_RDR gHC_SHOW (fsLit "showParen") + +typeOf_RDR, mkTypeRep_RDR, mkTyConRep_RDR :: RdrName +typeOf_RDR = varQual_RDR tYPEABLE (fsLit "typeOf") +mkTypeRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyConApp") +mkTyConRep_RDR = varQual_RDR tYPEABLE (fsLit "mkTyCon") + +undefined_RDR :: RdrName +undefined_RDR = varQual_RDR gHC_ERR (fsLit "undefined") + +error_RDR :: RdrName +error_RDR = varQual_RDR gHC_ERR (fsLit "error") + +-- Old Generics (constructors and functions) +crossDataCon_RDR, inlDataCon_RDR, inrDataCon_RDR, genUnitDataCon_RDR :: RdrName +crossDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:") +inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl") +inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr") +genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit") + +-- Generics (constructors and functions) +u1DataCon_RDR, par1DataCon_RDR, rec1DataCon_RDR, + k1DataCon_RDR, m1DataCon_RDR, l1DataCon_RDR, r1DataCon_RDR, + prodDataCon_RDR, comp1DataCon_RDR, from_RDR, from1_RDR, + to_RDR, to1_RDR, datatypeName_RDR, moduleName_RDR, conName_RDR, + conFixity_RDR, conIsRecord_RDR, + noArityDataCon_RDR, arityDataCon_RDR, selName_RDR, + prefixDataCon_RDR, infixDataCon_RDR, leftAssocDataCon_RDR, + rightAssocDataCon_RDR, notAssocDataCon_RDR :: RdrName + +u1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "U1") +par1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Par1") +rec1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Rec1") +k1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "K1") +m1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "M1") + +l1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "L1") +r1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "R1") + +prodDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit ":*:") +comp1DataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Comp1") + +from_RDR = varQual_RDR gHC_GENERICS (fsLit "from") +from1_RDR = varQual_RDR gHC_GENERICS (fsLit "from1") +to_RDR = varQual_RDR gHC_GENERICS (fsLit "to") +to1_RDR = varQual_RDR gHC_GENERICS (fsLit "to1") + +datatypeName_RDR = varQual_RDR gHC_GENERICS (fsLit "datatypeName") +moduleName_RDR = varQual_RDR gHC_GENERICS (fsLit "moduleName") +selName_RDR = varQual_RDR gHC_GENERICS (fsLit "selName") +conName_RDR = varQual_RDR gHC_GENERICS (fsLit "conName") +conFixity_RDR = varQual_RDR gHC_GENERICS (fsLit "conFixity") +conIsRecord_RDR = varQual_RDR gHC_GENERICS (fsLit "conIsRecord") + +noArityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NoArity") +arityDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Arity") +prefixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Prefix") +infixDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Infix") +leftAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "LeftAssociative") +rightAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "RightAssociative") +notAssocDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "NotAssociative") + + +fmap_RDR, pure_RDR, ap_RDR, foldable_foldr_RDR, traverse_RDR :: RdrName +fmap_RDR = varQual_RDR gHC_BASE (fsLit "fmap") +pure_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "pure") +ap_RDR = varQual_RDR cONTROL_APPLICATIVE (fsLit "<*>") +foldable_foldr_RDR = varQual_RDR dATA_FOLDABLE (fsLit "foldr") +traverse_RDR = varQual_RDR dATA_TRAVERSABLE (fsLit "traverse") ---------------------- +varQual_RDR, tcQual_RDR, clsQual_RDR, dataQual_RDR + :: Module -> FastString -> RdrName varQual_RDR mod str = mkOrig mod (mkOccNameFS varName str) tcQual_RDR mod str = mkOrig mod (mkOccNameFS tcName str) clsQual_RDR mod str = mkOrig mod (mkOccNameFS clsName str) @@ -475,229 +640,363 @@ and it's convenient to write them all down in one place. \begin{code} -runMainIOName = varQual gHC_TOP_HANDLER FSLIT("runMainIO") runMainKey - -orderingTyConName = tcQual gHC_BASE FSLIT("Ordering") orderingTyConKey - -eitherTyConName = tcQual dATA_EITHER FSLIT("Either") eitherTyConKey -leftDataConName = conName dATA_EITHER FSLIT("Left") leftDataConKey -rightDataConName = conName dATA_EITHER FSLIT("Right") rightDataConKey - --- Generics -crossTyConName = tcQual gHC_GENERICS FSLIT(":*:") crossTyConKey -plusTyConName = tcQual gHC_GENERICS FSLIT(":+:") plusTyConKey -genUnitTyConName = tcQual gHC_GENERICS FSLIT("Unit") genUnitTyConKey +wildCardName :: Name +wildCardName = mkSystemVarName wildCardKey (fsLit "wild") + +runMainIOName :: Name +runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey + +orderingTyConName :: Name +orderingTyConName = tcQual gHC_ORDERING (fsLit "Ordering") orderingTyConKey + +eitherTyConName, leftDataConName, rightDataConName :: Name +eitherTyConName = tcQual dATA_EITHER (fsLit "Either") eitherTyConKey +leftDataConName = conName dATA_EITHER (fsLit "Left") leftDataConKey +rightDataConName = conName dATA_EITHER (fsLit "Right") rightDataConKey + +-- Generics (types) +v1TyConName, u1TyConName, par1TyConName, rec1TyConName, + k1TyConName, m1TyConName, sumTyConName, prodTyConName, + compTyConName, rTyConName, pTyConName, dTyConName, + cTyConName, sTyConName, rec0TyConName, par0TyConName, + d1TyConName, c1TyConName, s1TyConName, noSelTyConName, + repTyConName, rep1TyConName :: Name + +v1TyConName = tcQual gHC_GENERICS (fsLit "V1") v1TyConKey +u1TyConName = tcQual gHC_GENERICS (fsLit "U1") u1TyConKey +par1TyConName = tcQual gHC_GENERICS (fsLit "Par1") par1TyConKey +rec1TyConName = tcQual gHC_GENERICS (fsLit "Rec1") rec1TyConKey +k1TyConName = tcQual gHC_GENERICS (fsLit "K1") k1TyConKey +m1TyConName = tcQual gHC_GENERICS (fsLit "M1") m1TyConKey + +sumTyConName = tcQual gHC_GENERICS (fsLit ":+:") sumTyConKey +prodTyConName = tcQual gHC_GENERICS (fsLit ":*:") prodTyConKey +compTyConName = tcQual gHC_GENERICS (fsLit ":.:") compTyConKey + +rTyConName = tcQual gHC_GENERICS (fsLit "R") rTyConKey +pTyConName = tcQual gHC_GENERICS (fsLit "P") pTyConKey +dTyConName = tcQual gHC_GENERICS (fsLit "D") dTyConKey +cTyConName = tcQual gHC_GENERICS (fsLit "C") cTyConKey +sTyConName = tcQual gHC_GENERICS (fsLit "S") sTyConKey + +rec0TyConName = tcQual gHC_GENERICS (fsLit "Rec0") rec0TyConKey +par0TyConName = tcQual gHC_GENERICS (fsLit "Par0") par0TyConKey +d1TyConName = tcQual gHC_GENERICS (fsLit "D1") d1TyConKey +c1TyConName = tcQual gHC_GENERICS (fsLit "C1") c1TyConKey +s1TyConName = tcQual gHC_GENERICS (fsLit "S1") s1TyConKey +noSelTyConName = tcQual gHC_GENERICS (fsLit "NoSelector") noSelTyConKey + +repTyConName = tcQual gHC_GENERICS (fsLit "Rep") repTyConKey +rep1TyConName = tcQual gHC_GENERICS (fsLit "Rep1") rep1TyConKey -- Base strings Strings -unpackCStringName = varQual gHC_BASE FSLIT("unpackCString#") unpackCStringIdKey -unpackCStringAppendName = varQual gHC_BASE FSLIT("unpackAppendCString#") unpackCStringAppendIdKey -unpackCStringFoldrName = varQual gHC_BASE FSLIT("unpackFoldrCString#") unpackCStringFoldrIdKey -unpackCStringUtf8Name = varQual gHC_BASE FSLIT("unpackCStringUtf8#") unpackCStringUtf8IdKey -eqStringName = varQual gHC_BASE FSLIT("eqString") eqStringIdKey -stringTyConName = tcQual gHC_BASE FSLIT("String") stringTyConKey +unpackCStringName, unpackCStringAppendName, unpackCStringFoldrName, + unpackCStringUtf8Name, eqStringName, stringTyConName :: Name +unpackCStringName = varQual gHC_CSTRING (fsLit "unpackCString#") unpackCStringIdKey +unpackCStringAppendName = varQual gHC_CSTRING (fsLit "unpackAppendCString#") unpackCStringAppendIdKey +unpackCStringFoldrName = varQual gHC_CSTRING (fsLit "unpackFoldrCString#") unpackCStringFoldrIdKey +unpackCStringUtf8Name = varQual gHC_CSTRING (fsLit "unpackCStringUtf8#") unpackCStringUtf8IdKey +eqStringName = varQual gHC_BASE (fsLit "eqString") eqStringIdKey +stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey -- The 'inline' function -inlineIdName = varQual gHC_BASE FSLIT("inline") inlineIdKey +inlineIdName :: Name +inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey -- Base classes (Eq, Ord, Functor) -eqClassName = clsQual gHC_BASE FSLIT("Eq") eqClassKey -eqName = methName gHC_BASE FSLIT("==") eqClassOpKey -ordClassName = clsQual gHC_BASE FSLIT("Ord") ordClassKey -geName = methName gHC_BASE FSLIT(">=") geClassOpKey -functorClassName = clsQual gHC_BASE FSLIT("Functor") functorClassKey +fmapName, eqClassName, eqName, ordClassName, geName, functorClassName :: Name +eqClassName = clsQual gHC_CLASSES (fsLit "Eq") eqClassKey +eqName = methName gHC_CLASSES (fsLit "==") eqClassOpKey +ordClassName = clsQual gHC_CLASSES (fsLit "Ord") ordClassKey +geName = methName gHC_CLASSES (fsLit ">=") geClassOpKey +functorClassName = clsQual gHC_BASE (fsLit "Functor") functorClassKey +fmapName = methName gHC_BASE (fsLit "fmap") fmapClassOpKey -- Class Monad -monadClassName = clsQual gHC_BASE FSLIT("Monad") monadClassKey -thenMName = methName gHC_BASE FSLIT(">>") thenMClassOpKey -bindMName = methName gHC_BASE FSLIT(">>=") bindMClassOpKey -returnMName = methName gHC_BASE FSLIT("return") returnMClassOpKey -failMName = methName gHC_BASE FSLIT("fail") failMClassOpKey +monadClassName, thenMName, bindMName, returnMName, failMName :: Name +monadClassName = clsQual gHC_BASE (fsLit "Monad") monadClassKey +thenMName = methName gHC_BASE (fsLit ">>") thenMClassOpKey +bindMName = methName gHC_BASE (fsLit ">>=") bindMClassOpKey +returnMName = methName gHC_BASE (fsLit "return") returnMClassOpKey +failMName = methName gHC_BASE (fsLit "fail") failMClassOpKey + +-- Classes (Applicative, Foldable, Traversable) +applicativeClassName, foldableClassName, traversableClassName :: Name +applicativeClassName = clsQual cONTROL_APPLICATIVE (fsLit "Applicative") applicativeClassKey +foldableClassName = clsQual dATA_FOLDABLE (fsLit "Foldable") foldableClassKey +traversableClassName = clsQual dATA_TRAVERSABLE (fsLit "Traversable") traversableClassKey -- Functions for GHC extensions -groupWithName = varQual gHC_EXTS FSLIT("groupWith") groupWithIdKey +groupWithName :: Name +groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey -- Random PrelBase functions -fromStringName = methName dATA_STRING FSLIT("fromString") fromStringClassOpKey -otherwiseIdName = varQual gHC_BASE FSLIT("otherwise") otherwiseIdKey -foldrName = varQual gHC_BASE FSLIT("foldr") foldrIdKey -buildName = varQual gHC_BASE FSLIT("build") buildIdKey -augmentName = varQual gHC_BASE FSLIT("augment") augmentIdKey -mapName = varQual gHC_BASE FSLIT("map") mapIdKey -appendName = varQual gHC_BASE FSLIT("++") appendIdKey -andName = varQual gHC_BASE FSLIT("&&") andIdKey -orName = varQual gHC_BASE FSLIT("||") orIdKey -assertName = varQual gHC_BASE FSLIT("assert") assertIdKey -breakpointName = varQual gHC_BASE FSLIT("breakpoint") breakpointIdKey -breakpointCondName= varQual gHC_BASE FSLIT("breakpointCond") breakpointCondIdKey -breakpointAutoName= varQual gHC_BASE FSLIT("breakpointAuto") breakpointAutoIdKey -opaqueTyConName = tcQual gHC_BASE FSLIT("Opaque") opaqueTyConKey - +fromStringName, otherwiseIdName, foldrName, buildName, augmentName, + mapName, appendName, assertName, + breakpointName, breakpointCondName, breakpointAutoName, + dollarName, opaqueTyConName :: Name +fromStringName = methName dATA_STRING (fsLit "fromString") fromStringClassOpKey +otherwiseIdName = varQual gHC_BASE (fsLit "otherwise") otherwiseIdKey +foldrName = varQual gHC_BASE (fsLit "foldr") foldrIdKey +buildName = varQual gHC_BASE (fsLit "build") buildIdKey +augmentName = varQual gHC_BASE (fsLit "augment") augmentIdKey +mapName = varQual gHC_BASE (fsLit "map") mapIdKey +appendName = varQual gHC_BASE (fsLit "++") appendIdKey +dollarName = varQual gHC_BASE (fsLit "$") dollarIdKey +assertName = varQual gHC_BASE (fsLit "assert") assertIdKey +breakpointName = varQual gHC_BASE (fsLit "breakpoint") breakpointIdKey +breakpointCondName= varQual gHC_BASE (fsLit "breakpointCond") breakpointCondIdKey +breakpointAutoName= varQual gHC_BASE (fsLit "breakpointAuto") breakpointAutoIdKey +opaqueTyConName = tcQual gHC_BASE (fsLit "Opaque") opaqueTyConKey + +breakpointJumpName :: Name breakpointJumpName = mkInternalName breakpointJumpIdKey - (mkOccNameFS varName FSLIT("breakpointJump")) + (mkOccNameFS varName (fsLit "breakpointJump")) noSrcSpan +breakpointCondJumpName :: Name breakpointCondJumpName = mkInternalName breakpointCondJumpIdKey - (mkOccNameFS varName FSLIT("breakpointCondJump")) + (mkOccNameFS varName (fsLit "breakpointCondJump")) noSrcSpan +breakpointAutoJumpName :: Name breakpointAutoJumpName = mkInternalName breakpointAutoJumpIdKey - (mkOccNameFS varName FSLIT("breakpointAutoJump")) + (mkOccNameFS varName (fsLit "breakpointAutoJump")) noSrcSpan -- PrelTup -fstName = varQual dATA_TUP FSLIT("fst") fstIdKey -sndName = varQual dATA_TUP FSLIT("snd") sndIdKey - --- Module PrelNum -numClassName = clsQual gHC_NUM FSLIT("Num") numClassKey -fromIntegerName = methName gHC_NUM FSLIT("fromInteger") fromIntegerClassOpKey -minusName = methName gHC_NUM FSLIT("-") minusClassOpKey -negateName = methName gHC_NUM FSLIT("negate") negateClassOpKey -plusIntegerName = varQual gHC_INTEGER FSLIT("plusInteger") plusIntegerIdKey -timesIntegerName = varQual gHC_INTEGER FSLIT("timesInteger") timesIntegerIdKey -integerTyConName = tcQual gHC_INTEGER FSLIT("Integer") integerTyConKey -smallIntegerName = varQual gHC_INTEGER FSLIT("smallInteger") smallIntegerIdKey - --- PrelReal types and classes -rationalTyConName = tcQual gHC_REAL FSLIT("Rational") rationalTyConKey -ratioTyConName = tcQual gHC_REAL FSLIT("Ratio") ratioTyConKey -ratioDataConName = conName gHC_REAL FSLIT(":%") ratioDataConKey -realClassName = clsQual gHC_REAL FSLIT("Real") realClassKey -integralClassName = clsQual gHC_REAL FSLIT("Integral") integralClassKey -realFracClassName = clsQual gHC_REAL FSLIT("RealFrac") realFracClassKey -fractionalClassName = clsQual gHC_REAL FSLIT("Fractional") fractionalClassKey -fromRationalName = methName gHC_REAL FSLIT("fromRational") fromRationalClassOpKey +fstName, sndName :: Name +fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey +sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey + +-- Module GHC.Num +numClassName, fromIntegerName, minusName, negateName, plusIntegerName, + timesIntegerName, + integerTyConName, smallIntegerName :: Name +numClassName = clsQual gHC_NUM (fsLit "Num") numClassKey +fromIntegerName = methName gHC_NUM (fsLit "fromInteger") fromIntegerClassOpKey +minusName = methName gHC_NUM (fsLit "-") minusClassOpKey +negateName = methName gHC_NUM (fsLit "negate") negateClassOpKey +plusIntegerName = varQual gHC_INTEGER (fsLit "plusInteger") plusIntegerIdKey +timesIntegerName = varQual gHC_INTEGER (fsLit "timesInteger") timesIntegerIdKey +integerTyConName = tcQual gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey +smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey + +-- GHC.Real types and classes +rationalTyConName, ratioTyConName, ratioDataConName, realClassName, + integralClassName, realFracClassName, fractionalClassName, + fromRationalName, toIntegerName, toRationalName, fromIntegralName, + realToFracName :: Name +rationalTyConName = tcQual gHC_REAL (fsLit "Rational") rationalTyConKey +ratioTyConName = tcQual gHC_REAL (fsLit "Ratio") ratioTyConKey +ratioDataConName = conName gHC_REAL (fsLit ":%") ratioDataConKey +realClassName = clsQual gHC_REAL (fsLit "Real") realClassKey +integralClassName = clsQual gHC_REAL (fsLit "Integral") integralClassKey +realFracClassName = clsQual gHC_REAL (fsLit "RealFrac") realFracClassKey +fractionalClassName = clsQual gHC_REAL (fsLit "Fractional") fractionalClassKey +fromRationalName = methName gHC_REAL (fsLit "fromRational") fromRationalClassOpKey +toIntegerName = methName gHC_REAL (fsLit "toInteger") toIntegerClassOpKey +toRationalName = methName gHC_REAL (fsLit "toRational") toRationalClassOpKey +fromIntegralName = varQual gHC_REAL (fsLit "fromIntegral") fromIntegralIdKey +realToFracName = varQual gHC_REAL (fsLit "realToFrac") realToFracIdKey -- PrelFloat classes -floatingClassName = clsQual gHC_FLOAT FSLIT("Floating") floatingClassKey -realFloatClassName = clsQual gHC_FLOAT FSLIT("RealFloat") realFloatClassKey +floatingClassName, realFloatClassName :: Name +floatingClassName = clsQual gHC_FLOAT (fsLit "Floating") floatingClassKey +realFloatClassName = clsQual gHC_FLOAT (fsLit "RealFloat") realFloatClassKey -- Class Ix -ixClassName = clsQual gHC_ARR FSLIT("Ix") ixClassKey +ixClassName :: Name +ixClassName = clsQual gHC_ARR (fsLit "Ix") ixClassKey -- Class Typeable -typeableClassName = clsQual tYPEABLE FSLIT("Typeable") typeableClassKey -typeable1ClassName = clsQual tYPEABLE FSLIT("Typeable1") typeable1ClassKey -typeable2ClassName = clsQual tYPEABLE FSLIT("Typeable2") typeable2ClassKey -typeable3ClassName = clsQual tYPEABLE FSLIT("Typeable3") typeable3ClassKey -typeable4ClassName = clsQual tYPEABLE FSLIT("Typeable4") typeable4ClassKey -typeable5ClassName = clsQual tYPEABLE FSLIT("Typeable5") typeable5ClassKey -typeable6ClassName = clsQual tYPEABLE FSLIT("Typeable6") typeable6ClassKey -typeable7ClassName = clsQual tYPEABLE FSLIT("Typeable7") typeable7ClassKey - +typeableClassName, typeable1ClassName, typeable2ClassName, + typeable3ClassName, typeable4ClassName, typeable5ClassName, + typeable6ClassName, typeable7ClassName :: Name +typeableClassName = clsQual tYPEABLE (fsLit "Typeable") typeableClassKey +typeable1ClassName = clsQual tYPEABLE (fsLit "Typeable1") typeable1ClassKey +typeable2ClassName = clsQual tYPEABLE (fsLit "Typeable2") typeable2ClassKey +typeable3ClassName = clsQual tYPEABLE (fsLit "Typeable3") typeable3ClassKey +typeable4ClassName = clsQual tYPEABLE (fsLit "Typeable4") typeable4ClassKey +typeable5ClassName = clsQual tYPEABLE (fsLit "Typeable5") typeable5ClassKey +typeable6ClassName = clsQual tYPEABLE (fsLit "Typeable6") typeable6ClassKey +typeable7ClassName = clsQual tYPEABLE (fsLit "Typeable7") typeable7ClassKey + +typeableClassNames :: [Name] typeableClassNames = [ typeableClassName, typeable1ClassName, typeable2ClassName , typeable3ClassName, typeable4ClassName, typeable5ClassName , typeable6ClassName, typeable7ClassName ] -- Class Data -dataClassName = clsQual gENERICS FSLIT("Data") dataClassKey +dataClassName :: Name +dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey -- Error module -assertErrorName = varQual gHC_ERR FSLIT("assertError") assertErrorIdKey +assertErrorName :: Name +assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey -- Enum module (Enum, Bounded) -enumClassName = clsQual gHC_ENUM FSLIT("Enum") enumClassKey -enumFromName = methName gHC_ENUM FSLIT("enumFrom") enumFromClassOpKey -enumFromToName = methName gHC_ENUM FSLIT("enumFromTo") enumFromToClassOpKey -enumFromThenName = methName gHC_ENUM FSLIT("enumFromThen") enumFromThenClassOpKey -enumFromThenToName = methName gHC_ENUM FSLIT("enumFromThenTo") enumFromThenToClassOpKey -boundedClassName = clsQual gHC_ENUM FSLIT("Bounded") boundedClassKey +enumClassName, enumFromName, enumFromToName, enumFromThenName, + enumFromThenToName, boundedClassName :: Name +enumClassName = clsQual gHC_ENUM (fsLit "Enum") enumClassKey +enumFromName = methName gHC_ENUM (fsLit "enumFrom") enumFromClassOpKey +enumFromToName = methName gHC_ENUM (fsLit "enumFromTo") enumFromToClassOpKey +enumFromThenName = methName gHC_ENUM (fsLit "enumFromThen") enumFromThenClassOpKey +enumFromThenToName = methName gHC_ENUM (fsLit "enumFromThenTo") enumFromThenToClassOpKey +boundedClassName = clsQual gHC_ENUM (fsLit "Bounded") boundedClassKey -- List functions -concatName = varQual gHC_LIST FSLIT("concat") concatIdKey -filterName = varQual gHC_LIST FSLIT("filter") filterIdKey -zipName = varQual gHC_LIST FSLIT("zip") zipIdKey +concatName, filterName, zipName :: Name +concatName = varQual gHC_LIST (fsLit "concat") concatIdKey +filterName = varQual gHC_LIST (fsLit "filter") filterIdKey +zipName = varQual gHC_LIST (fsLit "zip") zipIdKey -- Class Show -showClassName = clsQual gHC_SHOW FSLIT("Show") showClassKey +showClassName :: Name +showClassName = clsQual gHC_SHOW (fsLit "Show") showClassKey -- Class Read -readClassName = clsQual gHC_READ FSLIT("Read") readClassKey +readClassName :: Name +readClassName = clsQual gHC_READ (fsLit "Read") readClassKey + +-- Classes Generic and Generic1, Datatype, Constructor and Selector +genClassName, gen1ClassName, datatypeClassName, constructorClassName, + selectorClassName :: Name +genClassName = clsQual gHC_GENERICS (fsLit "Generic") genClassKey +gen1ClassName = clsQual gHC_GENERICS (fsLit "Generic1") gen1ClassKey + +datatypeClassName = clsQual gHC_GENERICS (fsLit "Datatype") datatypeClassKey +constructorClassName = clsQual gHC_GENERICS (fsLit "Constructor") constructorClassKey +selectorClassName = clsQual gHC_GENERICS (fsLit "Selector") selectorClassKey -- parallel array types and functions -enumFromToPName = varQual gHC_PARR FSLIT("enumFromToP") enumFromToPIdKey -enumFromThenToPName= varQual gHC_PARR FSLIT("enumFromThenToP") enumFromThenToPIdKey -nullPName = varQual gHC_PARR FSLIT("nullP") nullPIdKey -lengthPName = varQual gHC_PARR FSLIT("lengthP") lengthPIdKey -singletonPName = varQual gHC_PARR FSLIT("singletonP") singletonPIdKey -replicatePName = varQual gHC_PARR FSLIT("replicateP") replicatePIdKey -mapPName = varQual gHC_PARR FSLIT("mapP") mapPIdKey -filterPName = varQual gHC_PARR FSLIT("filterP") filterPIdKey -zipPName = varQual gHC_PARR FSLIT("zipP") zipPIdKey -crossMapPName = varQual gHC_PARR FSLIT("crossMapP") crossMapPIdKey -indexPName = varQual gHC_PARR FSLIT("!:") indexPIdKey -toPName = varQual gHC_PARR FSLIT("toP") toPIdKey -bpermutePName = varQual gHC_PARR FSLIT("bpermuteP") bpermutePIdKey -bpermuteDftPName = varQual gHC_PARR FSLIT("bpermuteDftP") bpermuteDftPIdKey -indexOfPName = varQual gHC_PARR FSLIT("indexOfP") indexOfPIdKey - --- IOBase things -ioTyConName = tcQual gHC_IO_BASE FSLIT("IO") ioTyConKey -ioDataConName = conName gHC_IO_BASE FSLIT("IO") ioDataConKey -thenIOName = varQual gHC_IO_BASE FSLIT("thenIO") thenIOIdKey -bindIOName = varQual gHC_IO_BASE FSLIT("bindIO") bindIOIdKey -returnIOName = varQual gHC_IO_BASE FSLIT("returnIO") returnIOIdKey -failIOName = varQual gHC_IO_BASE FSLIT("failIO") failIOIdKey +enumFromToPName, enumFromThenToPName, nullPName, lengthPName, + singletonPName, replicatePName, mapPName, filterPName, + zipPName, crossMapPName, indexPName, toPName, + emptyPName, appPName :: PackageId -> Name +enumFromToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromToP") enumFromToPIdKey +enumFromThenToPName pkg = varQual (gHC_PARR pkg) (fsLit "enumFromThenToP") enumFromThenToPIdKey +nullPName pkg = varQual (gHC_PARR pkg) (fsLit "nullP") nullPIdKey +lengthPName pkg = varQual (gHC_PARR pkg) (fsLit "lengthP") lengthPIdKey +singletonPName pkg = varQual (gHC_PARR pkg) (fsLit "singletonP") singletonPIdKey +replicatePName pkg = varQual (gHC_PARR pkg) (fsLit "replicateP") replicatePIdKey +mapPName pkg = varQual (gHC_PARR pkg) (fsLit "mapP") mapPIdKey +filterPName pkg = varQual (gHC_PARR pkg) (fsLit "filterP") filterPIdKey +zipPName pkg = varQual (gHC_PARR pkg) (fsLit "zipP") zipPIdKey +crossMapPName pkg = varQual (gHC_PARR pkg) (fsLit "crossMapP") crossMapPIdKey +indexPName pkg = varQual (gHC_PARR pkg) (fsLit "!:") indexPIdKey +toPName pkg = varQual (gHC_PARR pkg) (fsLit "toP") toPIdKey +emptyPName pkg = varQual (gHC_PARR pkg) (fsLit "emptyP") emptyPIdKey +appPName pkg = varQual (gHC_PARR pkg) (fsLit "+:+") appPIdKey + +-- code type things +hetmet_brak_name, hetmet_esc_name, hetmet_csp_name :: Name +hetmet_kappa_name, hetmet_kappa_app_name :: Name +hetmet_guest_integer_literal_name, hetmet_guest_string_literal_name, hetmet_guest_char_literal_name :: Name +hetmet_brak_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_brak") hetmet_brak_key +hetmet_esc_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_esc") hetmet_esc_key +hetmet_csp_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_csp") hetmet_csp_key +hetmet_kappa_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_kappa") hetmet_kappa_key +hetmet_kappa_app_name = varQual gHC_HETMET_CODETYPES (fsLit "hetmet_kappa_app") hetmet_kappa_app_key +hetmet_guest_integer_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestIntegerLiteral") hetmet_guest_integer_literal_key +hetmet_guest_string_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestStringLiteral") hetmet_guest_string_literal_key +hetmet_guest_char_literal_name = varQual gHC_HETMET_CODETYPES (fsLit "guestCharLiteral") hetmet_guest_char_literal_key -- IO things -printName = varQual sYSTEM_IO FSLIT("print") printIdKey +ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName, + failIOName :: Name +ioTyConName = tcQual gHC_TYPES (fsLit "IO") ioTyConKey +ioDataConName = conName gHC_TYPES (fsLit "IO") ioDataConKey +thenIOName = varQual gHC_BASE (fsLit "thenIO") thenIOIdKey +bindIOName = varQual gHC_BASE (fsLit "bindIO") bindIOIdKey +returnIOName = varQual gHC_BASE (fsLit "returnIO") returnIOIdKey +failIOName = varQual gHC_IO (fsLit "failIO") failIOIdKey + +-- IO things +printName :: Name +printName = varQual sYSTEM_IO (fsLit "print") printIdKey -- Int, Word, and Addr things -int8TyConName = tcQual gHC_INT FSLIT("Int8") int8TyConKey -int16TyConName = tcQual gHC_INT FSLIT("Int16") int16TyConKey -int32TyConName = tcQual gHC_INT FSLIT("Int32") int32TyConKey -int64TyConName = tcQual gHC_INT FSLIT("Int64") int64TyConKey +int8TyConName, int16TyConName, int32TyConName, int64TyConName :: Name +int8TyConName = tcQual gHC_INT (fsLit "Int8") int8TyConKey +int16TyConName = tcQual gHC_INT (fsLit "Int16") int16TyConKey +int32TyConName = tcQual gHC_INT (fsLit "Int32") int32TyConKey +int64TyConName = tcQual gHC_INT (fsLit "Int64") int64TyConKey -- Word module -word8TyConName = tcQual gHC_WORD FSLIT("Word8") word8TyConKey -word16TyConName = tcQual gHC_WORD FSLIT("Word16") word16TyConKey -word32TyConName = tcQual gHC_WORD FSLIT("Word32") word32TyConKey -word64TyConName = tcQual gHC_WORD FSLIT("Word64") word64TyConKey -wordTyConName = tcQual gHC_WORD FSLIT("Word") wordTyConKey -wordDataConName = conName gHC_WORD FSLIT("W#") wordDataConKey +word8TyConName, word16TyConName, word32TyConName, word64TyConName, + wordTyConName, wordDataConName :: Name +word8TyConName = tcQual gHC_WORD (fsLit "Word8") word8TyConKey +word16TyConName = tcQual gHC_WORD (fsLit "Word16") word16TyConKey +word32TyConName = tcQual gHC_WORD (fsLit "Word32") word32TyConKey +word64TyConName = tcQual gHC_WORD (fsLit "Word64") word64TyConKey +wordTyConName = tcQual gHC_WORD (fsLit "Word") wordTyConKey +wordDataConName = conName gHC_WORD (fsLit "W#") wordDataConKey -- PrelPtr module -ptrTyConName = tcQual gHC_PTR FSLIT("Ptr") ptrTyConKey -funPtrTyConName = tcQual gHC_PTR FSLIT("FunPtr") funPtrTyConKey +ptrTyConName, funPtrTyConName :: Name +ptrTyConName = tcQual gHC_PTR (fsLit "Ptr") ptrTyConKey +funPtrTyConName = tcQual gHC_PTR (fsLit "FunPtr") funPtrTyConKey -- Foreign objects and weak pointers -stablePtrTyConName = tcQual gHC_STABLE FSLIT("StablePtr") stablePtrTyConKey -newStablePtrName = varQual gHC_STABLE FSLIT("newStablePtr") newStablePtrIdKey +stablePtrTyConName, newStablePtrName :: Name +stablePtrTyConName = tcQual gHC_STABLE (fsLit "StablePtr") stablePtrTyConKey +newStablePtrName = varQual gHC_STABLE (fsLit "newStablePtr") newStablePtrIdKey -- PrelST module -runSTRepName = varQual gHC_ST FSLIT("runSTRep") runSTRepIdKey +runSTRepName :: Name +runSTRepName = varQual gHC_ST (fsLit "runSTRep") runSTRepIdKey -- Recursive-do notation -monadFixClassName = clsQual mONAD_FIX FSLIT("MonadFix") monadFixClassKey -mfixName = methName mONAD_FIX FSLIT("mfix") mfixIdKey +monadFixClassName, mfixName :: Name +monadFixClassName = clsQual mONAD_FIX (fsLit "MonadFix") monadFixClassKey +mfixName = methName mONAD_FIX (fsLit "mfix") mfixIdKey -- Arrow notation -arrAName = varQual aRROW FSLIT("arr") arrAIdKey -composeAName = varQual gHC_DESUGAR FSLIT(">>>") composeAIdKey -firstAName = varQual aRROW FSLIT("first") firstAIdKey -appAName = varQual aRROW FSLIT("app") appAIdKey -choiceAName = varQual aRROW FSLIT("|||") choiceAIdKey -loopAName = varQual aRROW FSLIT("loop") loopAIdKey +arrAName, composeAName, firstAName, appAName, choiceAName, loopAName :: Name +arrAName = varQual aRROW (fsLit "arr") arrAIdKey +composeAName = varQual gHC_DESUGAR (fsLit ">>>") composeAIdKey +firstAName = varQual aRROW (fsLit "first") firstAIdKey +appAName = varQual aRROW (fsLit "app") appAIdKey +choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey +loopAName = varQual aRROW (fsLit "loop") loopAIdKey + +-- Monad comprehensions +guardMName, liftMName, groupMName, mzipName :: Name +guardMName = varQual mONAD (fsLit "guard") guardMIdKey +liftMName = varQual mONAD (fsLit "liftM") liftMIdKey +groupMName = varQual mONAD_GROUP (fsLit "mgroupWith") groupMIdKey +mzipName = varQual mONAD_ZIP (fsLit "mzip") mzipIdKey + + +-- Annotation type checking +toAnnotationWrapperName :: Name +toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey -- Other classes, needed for type defaulting -monadPlusClassName = clsQual mONAD FSLIT("MonadPlus") monadPlusClassKey -randomClassName = clsQual rANDOM FSLIT("Random") randomClassKey -randomGenClassName = clsQual rANDOM FSLIT("RandomGen") randomGenClassKey -isStringClassName = clsQual dATA_STRING FSLIT("IsString") isStringClassKey +monadPlusClassName, randomClassName, randomGenClassName, + isStringClassName :: Name +monadPlusClassName = clsQual mONAD (fsLit "MonadPlus") monadPlusClassKey +randomClassName = clsQual rANDOM (fsLit "Random") randomClassKey +randomGenClassName = clsQual rANDOM (fsLit "RandomGen") randomGenClassKey +isStringClassName = clsQual dATA_STRING (fsLit "IsString") isStringClassKey -- dotnet interop -objectTyConName = tcQual dOTNET FSLIT("Object") objectTyConKey +objectTyConName :: Name +objectTyConName = tcQual dOTNET (fsLit "Object") objectTyConKey -- objectTyConName was "wTcQual", but that's gone now, and -- I can't see why it was wired in anyway... -unmarshalObjectName = varQual dOTNET FSLIT("unmarshalObject") unmarshalObjectIdKey -marshalObjectName = varQual dOTNET FSLIT("marshalObject") marshalObjectIdKey -marshalStringName = varQual dOTNET FSLIT("marshalString") marshalStringIdKey -unmarshalStringName = varQual dOTNET FSLIT("unmarshalString") unmarshalStringIdKey -checkDotnetResName = varQual dOTNET FSLIT("checkResult") checkDotnetResNameIdKey +unmarshalObjectName, marshalObjectName, marshalStringName, + unmarshalStringName, checkDotnetResName :: Name +unmarshalObjectName = varQual dOTNET (fsLit "unmarshalObject") unmarshalObjectIdKey +marshalObjectName = varQual dOTNET (fsLit "marshalObject") marshalObjectIdKey +marshalStringName = varQual dOTNET (fsLit "marshalString") marshalStringIdKey +unmarshalStringName = varQual dOTNET (fsLit "unmarshalString") unmarshalStringIdKey +checkDotnetResName = varQual dOTNET (fsLit "checkResult") checkDotnetResNameIdKey \end{code} %************************************************************************ @@ -709,20 +1008,22 @@ checkDotnetResName = varQual dOTNET FSLIT("checkResult") checkDotnetResNam All these are original names; hence mkOrig \begin{code} +varQual, tcQual, clsQual :: Module -> FastString -> Unique -> Name varQual = mk_known_key_name varName tcQual = mk_known_key_name tcName clsQual = mk_known_key_name clsName -mk_known_key_name space mod str uniq - = mkExternalName uniq mod (mkOccNameFS space str) noSrcSpan +mk_known_key_name :: NameSpace -> Module -> FastString -> Unique -> Name +mk_known_key_name space modu str unique + = mkExternalName unique modu (mkOccNameFS space str) noSrcSpan conName :: Module -> FastString -> Unique -> Name -conName mod occ uniq - = mkExternalName uniq mod (mkOccNameFS dataName occ) noSrcSpan +conName modu occ unique + = mkExternalName unique modu (mkOccNameFS dataName occ) noSrcSpan methName :: Module -> FastString -> Unique -> Name -methName mod occ uniq - = mkExternalName uniq mod (mkVarOccFS occ) noSrcSpan +methName modu occ unique + = mkExternalName unique modu (mkVarOccFS occ) noSrcSpan \end{code} %************************************************************************ @@ -733,6 +1034,10 @@ methName mod occ uniq --MetaHaskell extension hand allocate keys here \begin{code} +boundedClassKey, enumClassKey, eqClassKey, floatingClassKey, + fractionalClassKey, integralClassKey, monadClassKey, dataClassKey, + functorClassKey, numClassKey, ordClassKey, readClassKey, realClassKey, + realFloatClassKey, realFracClassKey, showClassKey, ixClassKey :: Unique boundedClassKey = mkPreludeClassUnique 1 enumClassKey = mkPreludeClassUnique 2 eqClassKey = mkPreludeClassUnique 3 @@ -751,6 +1056,9 @@ realFracClassKey = mkPreludeClassUnique 16 showClassKey = mkPreludeClassUnique 17 ixClassKey = mkPreludeClassUnique 18 +typeableClassKey, typeable1ClassKey, typeable2ClassKey, typeable3ClassKey, + typeable4ClassKey, typeable5ClassKey, typeable6ClassKey, typeable7ClassKey + :: Unique typeableClassKey = mkPreludeClassUnique 20 typeable1ClassKey = mkPreludeClassUnique 21 typeable2ClassKey = mkPreludeClassUnique 22 @@ -760,13 +1068,30 @@ typeable5ClassKey = mkPreludeClassUnique 25 typeable6ClassKey = mkPreludeClassUnique 26 typeable7ClassKey = mkPreludeClassUnique 27 +monadFixClassKey :: Unique monadFixClassKey = mkPreludeClassUnique 28 +monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique monadPlusClassKey = mkPreludeClassUnique 30 randomClassKey = mkPreludeClassUnique 31 randomGenClassKey = mkPreludeClassUnique 32 +isStringClassKey :: Unique isStringClassKey = mkPreludeClassUnique 33 + +applicativeClassKey, foldableClassKey, traversableClassKey :: Unique +applicativeClassKey = mkPreludeClassUnique 34 +foldableClassKey = mkPreludeClassUnique 35 +traversableClassKey = mkPreludeClassUnique 36 + +genClassKey, gen1ClassKey, datatypeClassKey, constructorClassKey, + selectorClassKey :: Unique +genClassKey = mkPreludeClassUnique 37 +gen1ClassKey = mkPreludeClassUnique 38 + +datatypeClassKey = mkPreludeClassUnique 39 +constructorClassKey = mkPreludeClassUnique 40 +selectorClassKey = mkPreludeClassUnique 41 \end{code} %************************************************************************ @@ -776,6 +1101,16 @@ isStringClassKey = mkPreludeClassUnique 33 %************************************************************************ \begin{code} +addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey, + charPrimTyConKey, charTyConKey, doublePrimTyConKey, doubleTyConKey, + floatPrimTyConKey, floatTyConKey, funTyConKey, intPrimTyConKey, + intTyConKey, int8TyConKey, int16TyConKey, int32PrimTyConKey, + int32TyConKey, int64PrimTyConKey, int64TyConKey, integerTyConKey, + listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey, + mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey, + orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey, + realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey, + anyTyConKey :: Unique addrPrimTyConKey = mkPreludeTyConUnique 1 arrayPrimTyConKey = mkPreludeTyConUnique 3 boolTyConKey = mkPreludeTyConUnique 4 @@ -808,14 +1143,20 @@ rationalTyConKey = mkPreludeTyConUnique 33 realWorldTyConKey = mkPreludeTyConUnique 34 stablePtrPrimTyConKey = mkPreludeTyConUnique 35 stablePtrTyConKey = mkPreludeTyConUnique 36 - -anyPrimTyConKey = mkPreludeTyConUnique 37 -anyPrimTyCon1Key = mkPreludeTyConUnique 38 - +anyTyConKey = mkPreludeTyConUnique 37 + +statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey, + mutVarPrimTyConKey, ioTyConKey, + wordPrimTyConKey, wordTyConKey, word8TyConKey, word16TyConKey, + word32PrimTyConKey, word32TyConKey, word64PrimTyConKey, word64TyConKey, + liftedConKey, unliftedConKey, anyBoxConKey, kindConKey, boxityConKey, + typeConKey, threadIdPrimTyConKey, bcoPrimTyConKey, ptrTyConKey, + funPtrTyConKey, tVarPrimTyConKey, eqPredPrimTyConKey :: Unique statePrimTyConKey = mkPreludeTyConUnique 50 stableNamePrimTyConKey = mkPreludeTyConUnique 51 -stableNameTyConKey = mkPreludeTyConUnique 52 -mutVarPrimTyConKey = mkPreludeTyConUnique 55 +stableNameTyConKey = mkPreludeTyConUnique 52 +eqPredPrimTyConKey = mkPreludeTyConUnique 53 +mutVarPrimTyConKey = mkPreludeTyConUnique 55 ioTyConKey = mkPreludeTyConUnique 56 wordPrimTyConKey = mkPreludeTyConUnique 58 wordTyConKey = mkPreludeTyConUnique 59 @@ -837,24 +1178,24 @@ ptrTyConKey = mkPreludeTyConUnique 74 funPtrTyConKey = mkPreludeTyConUnique 75 tVarPrimTyConKey = mkPreludeTyConUnique 76 --- Generic Type Constructors -crossTyConKey = mkPreludeTyConUnique 79 -plusTyConKey = mkPreludeTyConUnique 80 -genUnitTyConKey = mkPreludeTyConUnique 81 - -- Parallel array type constructor +parrTyConKey :: Unique parrTyConKey = mkPreludeTyConUnique 82 -- dotnet interop +objectTyConKey :: Unique objectTyConKey = mkPreludeTyConUnique 83 +eitherTyConKey :: Unique eitherTyConKey = mkPreludeTyConUnique 84 -- Super Kinds constructors +tySuperKindTyConKey :: Unique tySuperKindTyConKey = mkPreludeTyConUnique 85 -coSuperKindTyConKey = mkPreludeTyConUnique 86 -- Kind constructors +liftedTypeKindTyConKey, openTypeKindTyConKey, unliftedTypeKindTyConKey, + ubxTupleKindTyConKey, argTypeKindTyConKey :: Unique liftedTypeKindTyConKey = mkPreludeTyConUnique 87 openTypeKindTyConKey = mkPreludeTyConUnique 88 unliftedTypeKindTyConKey = mkPreludeTyConUnique 89 @@ -862,25 +1203,71 @@ ubxTupleKindTyConKey = mkPreludeTyConUnique 90 argTypeKindTyConKey = mkPreludeTyConUnique 91 -- Coercion constructors +symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey, + rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey, + csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey + :: Unique symCoercionTyConKey = mkPreludeTyConUnique 93 transCoercionTyConKey = mkPreludeTyConUnique 94 leftCoercionTyConKey = mkPreludeTyConUnique 95 rightCoercionTyConKey = mkPreludeTyConUnique 96 instCoercionTyConKey = mkPreludeTyConUnique 97 unsafeCoercionTyConKey = mkPreludeTyConUnique 98 +csel1CoercionTyConKey = mkPreludeTyConUnique 99 +csel2CoercionTyConKey = mkPreludeTyConUnique 100 +cselRCoercionTyConKey = mkPreludeTyConUnique 101 -unknownTyConKey = mkPreludeTyConUnique 99 +unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey, + opaqueTyConKey :: Unique +unknownTyConKey = mkPreludeTyConUnique 129 unknown1TyConKey = mkPreludeTyConUnique 130 unknown2TyConKey = mkPreludeTyConUnique 131 unknown3TyConKey = mkPreludeTyConUnique 132 opaqueTyConKey = mkPreludeTyConUnique 133 +stringTyConKey :: Unique stringTyConKey = mkPreludeTyConUnique 134 +-- Generics (Unique keys) +v1TyConKey, u1TyConKey, par1TyConKey, rec1TyConKey, + k1TyConKey, m1TyConKey, sumTyConKey, prodTyConKey, + compTyConKey, rTyConKey, pTyConKey, dTyConKey, + cTyConKey, sTyConKey, rec0TyConKey, par0TyConKey, + d1TyConKey, c1TyConKey, s1TyConKey, noSelTyConKey, + repTyConKey, rep1TyConKey :: Unique + +v1TyConKey = mkPreludeTyConUnique 135 +u1TyConKey = mkPreludeTyConUnique 136 +par1TyConKey = mkPreludeTyConUnique 137 +rec1TyConKey = mkPreludeTyConUnique 138 +k1TyConKey = mkPreludeTyConUnique 139 +m1TyConKey = mkPreludeTyConUnique 140 + +sumTyConKey = mkPreludeTyConUnique 141 +prodTyConKey = mkPreludeTyConUnique 142 +compTyConKey = mkPreludeTyConUnique 143 + +rTyConKey = mkPreludeTyConUnique 144 +pTyConKey = mkPreludeTyConUnique 145 +dTyConKey = mkPreludeTyConUnique 146 +cTyConKey = mkPreludeTyConUnique 147 +sTyConKey = mkPreludeTyConUnique 148 + +rec0TyConKey = mkPreludeTyConUnique 149 +par0TyConKey = mkPreludeTyConUnique 150 +d1TyConKey = mkPreludeTyConUnique 151 +c1TyConKey = mkPreludeTyConUnique 152 +s1TyConKey = mkPreludeTyConUnique 153 +noSelTyConKey = mkPreludeTyConUnique 154 + +repTyConKey = mkPreludeTyConUnique 155 +rep1TyConKey = mkPreludeTyConUnique 156 + ---------------- Template Haskell ------------------- --- USES TyConUniques 100-129 +-- USES TyConUniques 200-299 ----------------------------------------------------- +unitTyConKey :: Unique unitTyConKey = mkTupleTyConUnique Boxed 0 \end{code} @@ -891,6 +1278,10 @@ unitTyConKey = mkTupleTyConUnique Boxed 0 %************************************************************************ \begin{code} +charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey, + floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey, + stableNameDataConKey, trueDataConKey, wordDataConKey, + ioDataConKey, integerDataConKey :: Unique charDataConKey = mkPreludeDataConUnique 1 consDataConKey = mkPreludeDataConUnique 2 doubleDataConKey = mkPreludeDataConUnique 3 @@ -903,18 +1294,26 @@ stableNameDataConKey = mkPreludeDataConUnique 14 trueDataConKey = mkPreludeDataConUnique 15 wordDataConKey = mkPreludeDataConUnique 16 ioDataConKey = mkPreludeDataConUnique 17 +integerDataConKey = mkPreludeDataConUnique 18 -- Generic data constructors +crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique crossDataConKey = mkPreludeDataConUnique 20 inlDataConKey = mkPreludeDataConUnique 21 inrDataConKey = mkPreludeDataConUnique 22 genUnitDataConKey = mkPreludeDataConUnique 23 -- Data constructor for parallel arrays +parrDataConKey :: Unique parrDataConKey = mkPreludeDataConUnique 24 +leftDataConKey, rightDataConKey :: Unique leftDataConKey = mkPreludeDataConUnique 25 rightDataConKey = mkPreludeDataConUnique 26 + +-- Data constructor for Heterogeneous Metaprogramming code types +hetMetCodeTypeDataConKey :: Unique +hetMetCodeTypeDataConKey = mkPreludeDataConUnique 27 \end{code} %************************************************************************ @@ -924,7 +1323,19 @@ rightDataConKey = mkPreludeDataConUnique 26 %************************************************************************ \begin{code} -absentErrorIdKey = mkPreludeMiscIdUnique 1 +absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey, + foldlIdKey, foldrIdKey, recSelErrorIdKey, + integerMinusOneIdKey, integerPlusOneIdKey, + integerPlusTwoIdKey, integerZeroIdKey, + int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey, + noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey, + runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey, + realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey, + traceIdKey, wildCardKey, + unpackCStringUtf8IdKey, unpackCStringAppendIdKey, + unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique +wildCardKey = mkPreludeMiscIdUnique 0 -- See Note [WildCard] +absentErrorIdKey = mkPreludeMiscIdUnique 1 augmentIdKey = mkPreludeMiscIdUnique 3 appendIdKey = mkPreludeMiscIdUnique 4 buildIdKey = mkPreludeMiscIdUnique 5 @@ -955,6 +1366,11 @@ unpackCStringAppendIdKey = mkPreludeMiscIdUnique 29 unpackCStringFoldrIdKey = mkPreludeMiscIdUnique 30 unpackCStringIdKey = mkPreludeMiscIdUnique 31 +unsafeCoerceIdKey, concatIdKey, filterIdKey, zipIdKey, bindIOIdKey, + returnIOIdKey, deRefStablePtrIdKey, newStablePtrIdKey, + smallIntegerIdKey, plusIntegerIdKey, timesIntegerIdKey, + printIdKey, failIOIdKey, nullAddrIdKey, voidArgIdKey, + fstIdKey, sndIdKey, otherwiseIdKey, assertIdKey, runSTRepIdKey :: Unique unsafeCoerceIdKey = mkPreludeMiscIdUnique 32 concatIdKey = mkPreludeMiscIdUnique 33 filterIdKey = mkPreludeMiscIdUnique 34 @@ -963,7 +1379,7 @@ bindIOIdKey = mkPreludeMiscIdUnique 36 returnIOIdKey = mkPreludeMiscIdUnique 37 deRefStablePtrIdKey = mkPreludeMiscIdUnique 38 newStablePtrIdKey = mkPreludeMiscIdUnique 39 -smallIntegerIdKey = mkPreludeMiscIdUnique 40 +smallIntegerIdKey = mkPreludeMiscIdUnique 40 plusIntegerIdKey = mkPreludeMiscIdUnique 41 timesIntegerIdKey = mkPreludeMiscIdUnique 42 printIdKey = mkPreludeMiscIdUnique 43 @@ -976,15 +1392,18 @@ otherwiseIdKey = mkPreludeMiscIdUnique 51 assertIdKey = mkPreludeMiscIdUnique 53 runSTRepIdKey = mkPreludeMiscIdUnique 54 +rootMainKey, runMainKey :: Unique rootMainKey = mkPreludeMiscIdUnique 55 runMainKey = mkPreludeMiscIdUnique 56 -andIdKey = mkPreludeMiscIdUnique 57 -orIdKey = mkPreludeMiscIdUnique 58 +thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique thenIOIdKey = mkPreludeMiscIdUnique 59 lazyIdKey = mkPreludeMiscIdUnique 60 assertErrorIdKey = mkPreludeMiscIdUnique 61 +breakpointIdKey, breakpointCondIdKey, breakpointAutoIdKey, + breakpointJumpIdKey, breakpointCondJumpIdKey, + breakpointAutoJumpIdKey :: Unique breakpointIdKey = mkPreludeMiscIdUnique 62 breakpointCondIdKey = mkPreludeMiscIdUnique 63 breakpointAutoIdKey = mkPreludeMiscIdUnique 64 @@ -992,12 +1411,21 @@ breakpointJumpIdKey = mkPreludeMiscIdUnique 65 breakpointCondJumpIdKey = mkPreludeMiscIdUnique 66 breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67 +inlineIdKey :: Unique inlineIdKey = mkPreludeMiscIdUnique 68 -mapIdKey = mkPreludeMiscIdUnique 69 +mapIdKey, groupWithIdKey, dollarIdKey :: Unique +mapIdKey = mkPreludeMiscIdUnique 69 groupWithIdKey = mkPreludeMiscIdUnique 70 +dollarIdKey = mkPreludeMiscIdUnique 71 + +coercionTokenIdKey :: Unique +coercionTokenIdKey = mkPreludeMiscIdUnique 72 -- Parallel array functions +singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey, + filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey, + enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique singletonPIdKey = mkPreludeMiscIdUnique 79 nullPIdKey = mkPreludeMiscIdUnique 80 lengthPIdKey = mkPreludeMiscIdUnique 81 @@ -1010,11 +1438,12 @@ indexPIdKey = mkPreludeMiscIdUnique 87 toPIdKey = mkPreludeMiscIdUnique 88 enumFromToPIdKey = mkPreludeMiscIdUnique 89 enumFromThenToPIdKey = mkPreludeMiscIdUnique 90 -bpermutePIdKey = mkPreludeMiscIdUnique 91 -bpermuteDftPIdKey = mkPreludeMiscIdUnique 92 -indexOfPIdKey = mkPreludeMiscIdUnique 93 +emptyPIdKey = mkPreludeMiscIdUnique 91 +appPIdKey = mkPreludeMiscIdUnique 92 -- dotnet interop +unmarshalObjectIdKey, marshalObjectIdKey, marshalStringIdKey, + unmarshalStringIdKey, checkDotnetResNameIdKey :: Unique unmarshalObjectIdKey = mkPreludeMiscIdUnique 94 marshalObjectIdKey = mkPreludeMiscIdUnique 95 marshalStringIdKey = mkPreludeMiscIdUnique 96 @@ -1029,8 +1458,15 @@ during type checking. \begin{code} -- Just a place holder for unbound variables produced by the renamer: +unboundKey :: Unique unboundKey = mkPreludeMiscIdUnique 101 +fromIntegerClassOpKey, minusClassOpKey, fromRationalClassOpKey, + enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey, + enumFromThenToClassOpKey, eqClassOpKey, geClassOpKey, negateClassOpKey, + failMClassOpKey, bindMClassOpKey, thenMClassOpKey, returnMClassOpKey, + fmapClassOpKey + :: Unique fromIntegerClassOpKey = mkPreludeMiscIdUnique 102 minusClassOpKey = mkPreludeMiscIdUnique 103 fromRationalClassOpKey = mkPreludeMiscIdUnique 104 @@ -1044,12 +1480,16 @@ negateClassOpKey = mkPreludeMiscIdUnique 111 failMClassOpKey = mkPreludeMiscIdUnique 112 bindMClassOpKey = mkPreludeMiscIdUnique 113 -- (>>=) thenMClassOpKey = mkPreludeMiscIdUnique 114 -- (>>) +fmapClassOpKey = mkPreludeMiscIdUnique 115 returnMClassOpKey = mkPreludeMiscIdUnique 117 -- Recursive do notation +mfixIdKey :: Unique mfixIdKey = mkPreludeMiscIdUnique 118 -- Arrow notation +arrAIdKey, composeAIdKey, firstAIdKey, appAIdKey, choiceAIdKey, + loopAIdKey :: Unique arrAIdKey = mkPreludeMiscIdUnique 119 composeAIdKey = mkPreludeMiscIdUnique 120 -- >>> firstAIdKey = mkPreludeMiscIdUnique 121 @@ -1057,10 +1497,48 @@ appAIdKey = mkPreludeMiscIdUnique 122 choiceAIdKey = mkPreludeMiscIdUnique 123 -- ||| loopAIdKey = mkPreludeMiscIdUnique 124 +fromStringClassOpKey :: Unique fromStringClassOpKey = mkPreludeMiscIdUnique 125 +-- Annotation type checking +toAnnotationWrapperIdKey :: Unique +toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126 + +-- Conversion functions +fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique +fromIntegralIdKey = mkPreludeMiscIdUnique 127 +realToFracIdKey = mkPreludeMiscIdUnique 128 +toIntegerClassOpKey = mkPreludeMiscIdUnique 129 +toRationalClassOpKey = mkPreludeMiscIdUnique 130 + +-- Monad comprehensions +guardMIdKey, liftMIdKey, groupMIdKey, mzipIdKey :: Unique +guardMIdKey = mkPreludeMiscIdUnique 131 +liftMIdKey = mkPreludeMiscIdUnique 132 +groupMIdKey = mkPreludeMiscIdUnique 133 +mzipIdKey = mkPreludeMiscIdUnique 134 + +-- code types +hetMetCodeTypeTyConKey :: Unique +hetMetCodeTypeTyConKey = mkPreludeTyConUnique 135 +hetMetKappaTyConKey :: Unique +hetMetKappaTyConKey = mkPreludeTyConUnique 137 + +hetmet_guest_integer_literal_key, hetmet_guest_string_literal_key, hetmet_guest_char_literal_key :: Unique +hetmet_guest_integer_literal_key = mkPreludeMiscIdUnique 138 +hetmet_guest_string_literal_key = mkPreludeMiscIdUnique 139 +hetmet_guest_char_literal_key = mkPreludeMiscIdUnique 140 + +hetmet_brak_key, hetmet_esc_key, hetmet_csp_key :: Unique +hetmet_brak_key = mkPreludeMiscIdUnique 141 +hetmet_esc_key = mkPreludeMiscIdUnique 143 +hetmet_csp_key = mkPreludeMiscIdUnique 145 +hetmet_kappa_key = mkPreludeMiscIdUnique 146 +hetmet_kappa_app_key = mkPreludeMiscIdUnique 147 + + ---------------- Template Haskell ------------------- --- USES IdUniques 200-399 +-- USES IdUniques 200-499 ----------------------------------------------------- \end{code} @@ -1072,13 +1550,21 @@ fromStringClassOpKey = mkPreludeMiscIdUnique 125 %************************************************************************ \begin{code} -numericTyKeys = +numericTyKeys :: [Unique] +numericTyKeys = [ wordTyConKey , intTyConKey , integerTyConKey , doubleTyConKey , floatTyConKey ] + +kindKeys :: [Unique] +kindKeys = [ liftedTypeKindTyConKey + , openTypeKindTyConKey + , unliftedTypeKindTyConKey + , ubxTupleKindTyConKey + , argTypeKindTyConKey ] \end{code} @@ -1093,6 +1579,7 @@ even though every numeric class has these two as a superclass, because the list of ambiguous dictionaries hasn't been simplified. \begin{code} +numericClassKeys :: [Unique] numericClassKeys = [ numClassKey , realClassKey @@ -1100,6 +1587,7 @@ numericClassKeys = ] ++ fractionalClassKeys +fractionalClassKeys :: [Unique] fractionalClassKeys = [ fractionalClassKey , floatingClassKey @@ -1109,17 +1597,20 @@ fractionalClassKeys = -- the strictness analyser needs to know about numeric types -- (see SaAbsInt.lhs) +needsDataDeclCtxtClassKeys :: [Unique] needsDataDeclCtxtClassKeys = -- see comments in TcDeriv [ readClassKey ] -- The "standard classes" are used in defaulting (Haskell 98 report 4.3.4), -- and are: "classes defined in the Prelude or a standard library" +standardClassKeys :: [Unique] standardClassKeys = derivableClassKeys ++ numericClassKeys ++ [randomClassKey, randomGenClassKey, functorClassKey, monadClassKey, monadPlusClassKey, - isStringClassKey + isStringClassKey, + applicativeClassKey, foldableClassKey, traversableClassKey ] \end{code} @@ -1127,6 +1618,7 @@ standardClassKeys = derivableClassKeys ++ numericClassKeys (@TcDeriv@). \begin{code} +derivableClassKeys :: [Unique] derivableClassKeys = [ eqClassKey, ordClassKey, enumClassKey, ixClassKey, boundedClassKey, showClassKey, readClassKey ]