mkTupleTyConUnique
)
import BasicTypes ( Boxity(..), Arity )
-import Name ( Name, mkInternalName, mkExternalName )
+import Name ( Name, mkInternalName, mkExternalName, mkSystemVarName )
import SrcLoc
import FastString
\end{code}
%************************************************************************
-%* *
+%* *
\subsection{Known key Names}
-%* *
+%* *
%************************************************************************
This section tells what the compiler knows about the assocation 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,
traversableClassName,
-- Numeric stuff
- negateName, minusName,
- fromRationalName, fromIntegerName,
- geName, eqName,
+ negateName, minusName, geName, eqName,
+
+ -- Conversion functions
+ fromRationalName, fromIntegerName,
+ toIntegerName, toRationalName,
+ fromIntegralName, realToFracName,
-- String stuff
fromStringName,
-- Enum stuff
enumFromName, enumFromThenName,
enumFromThenToName, enumFromToName,
- enumFromToPName, enumFromThenToPName,
-- Monad stuff
thenIOName, bindIOName, returnIOName, failIOName,
dollarName, -- The ($) apply function
- -- Parallel array operations
- nullPName, lengthPName, replicatePName, singletonPName, mapPName,
- filterPName, zipPName, crossMapPName, indexPName,
- toPName, emptyPName, appPName,
-
-- FFI primitive types that are not wired-in.
stablePtrTyConName, ptrTyConName, funPtrTyConName,
int8TyConName, int16TyConName, int32TyConName, int64TyConName,
genericTyConNames :: [Name]
genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName]
+
+-- 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}
pRELUDE :: Module
pRELUDE = mkBaseModule_ pRELUDE_NAME
-gHC_PRIM, gHC_TYPES, gHC_BOOL, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
+gHC_PRIM, gHC_TYPES, gHC_UNIT, gHC_ORDERING, gHC_GENERICS,
gHC_MAGIC,
gHC_CLASSES, gHC_BASE, gHC_ENUM,
- gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST, gHC_PARR,
+ gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_INTEGER_TYPE, gHC_LIST,
gHC_TUPLE, dATA_TUPLE, dATA_EITHER, dATA_STRING, dATA_FOLDABLE, dATA_TRAVERSABLE,
gHC_PACK, gHC_CONC, gHC_IO, gHC_IO_Exception,
gHC_ST, gHC_ARR, gHC_STABLE, gHC_ADDR, gHC_PTR, gHC_ERR, gHC_REAL,
gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values
gHC_TYPES = mkPrimModule (fsLit "GHC.Types")
gHC_UNIT = mkPrimModule (fsLit "GHC.Unit")
-gHC_BOOL = mkPrimModule (fsLit "GHC.Bool")
gHC_ORDERING = mkPrimModule (fsLit "GHC.Ordering")
gHC_GENERICS = mkPrimModule (fsLit "GHC.Generics")
gHC_MAGIC = mkPrimModule (fsLit "GHC.Magic")
gHC_NUM = mkBaseModule (fsLit "GHC.Num")
gHC_INTEGER = mkIntegerModule (fsLit "GHC.Integer")
gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type")
-gHC_LIST = mkBaseModule (fsLit "GHC.List")
-gHC_PARR = mkBaseModule (fsLit "GHC.PArr")
-gHC_TUPLE = mkPrimModule (fsLit "GHC.Tuple")
-dATA_TUPLE = mkBaseModule (fsLit "Data.Tuple")
+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")
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
\begin{code}
+wildCardName :: Name
+wildCardName = mkSystemVarName wildCardKey (fsLit "wild")
+
runMainIOName :: Name
runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey
fstName = varQual dATA_TUPLE (fsLit "fst") fstIdKey
sndName = varQual dATA_TUPLE (fsLit "snd") sndIdKey
--- Module PrelNum
+-- Module GHC.Num
numClassName, fromIntegerName, minusName, negateName, plusIntegerName,
timesIntegerName,
integerTyConName, smallIntegerName :: Name
integerTyConName = tcQual gHC_INTEGER_TYPE (fsLit "Integer") integerTyConKey
smallIntegerName = varQual gHC_INTEGER (fsLit "smallInteger") smallIntegerIdKey
--- PrelReal types and classes
+-- GHC.Real types and classes
rationalTyConName, ratioTyConName, ratioDataConName, realClassName,
integralClassName, realFracClassName, fractionalClassName,
- fromRationalName :: Name
+ 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
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
+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, realFloatClassName :: Name
enumFromToPName, enumFromThenToPName, nullPName, lengthPName,
singletonPName, replicatePName, mapPName, filterPName,
zipPName, crossMapPName, indexPName, toPName,
- emptyPName, appPName :: Name
-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
-emptyPName = varQual gHC_PARR (fsLit "emptyP") emptyPIdKey
-appPName = varQual gHC_PARR (fsLit "+:+") appPIdKey
+ 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
-- IO things
ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName,
stringTyConKey = mkPreludeTyConUnique 134
---------------- Template Haskell -------------------
--- USES TyConUniques 100-129
+-- USES TyConUniques 200-299
-----------------------------------------------------
unitTyConKey :: Unique
noMethodBindingErrorIdKey, nonExhaustiveGuardsErrorIdKey,
runtimeErrorIdKey, parErrorIdKey, parIdKey, patErrorIdKey,
realWorldPrimIdKey, recConErrorIdKey, recUpdErrorIdKey,
- traceIdKey,
+ traceIdKey, wildCardKey,
unpackCStringUtf8IdKey, unpackCStringAppendIdKey,
unpackCStringFoldrIdKey, unpackCStringIdKey :: Unique
-absentErrorIdKey = mkPreludeMiscIdUnique 1
+wildCardKey = mkPreludeMiscIdUnique 0 -- See Note [WildCard]
+absentErrorIdKey = mkPreludeMiscIdUnique 1
augmentIdKey = mkPreludeMiscIdUnique 3
appendIdKey = mkPreludeMiscIdUnique 4
buildIdKey = mkPreludeMiscIdUnique 5
toAnnotationWrapperIdKey :: Unique
toAnnotationWrapperIdKey = mkPreludeMiscIdUnique 126
+-- Conversion functions
+fromIntegralIdKey, realToFracIdKey, toIntegerClassOpKey, toRationalClassOpKey :: Unique
+fromIntegralIdKey = mkPreludeMiscIdUnique 127
+realToFracIdKey = mkPreludeMiscIdUnique 128
+toIntegerClassOpKey = mkPreludeMiscIdUnique 129
+toRationalClassOpKey = mkPreludeMiscIdUnique 130
---------------- Template Haskell -------------------
--- USES IdUniques 200-399
+-- USES IdUniques 200-499
-----------------------------------------------------
\end{code}