X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fprelude%2FPrelNames.lhs;h=f92d94e28deb42b4c0295cb0eeadd29d18d36f02;hp=27d253b37cf512df716a67fda0ba68fb1c9fdf8d;hb=f2aaae9757e7532485c97f6c9a9ed5437542d1dd;hpb=ed4c5b9f46e502f04b74922e8440731537ee30d2 diff --git a/compiler/prelude/PrelNames.lhs b/compiler/prelude/PrelNames.lhs index 27d253b..f92d94e 100644 --- a/compiler/prelude/PrelNames.lhs +++ b/compiler/prelude/PrelNames.lhs @@ -6,33 +6,33 @@ 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} @@ -58,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} @@ -89,20 +89,27 @@ isUnboundName name = name `hasKey` unboundKey %************************************************************************ -%* * +%* * \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, @@ -131,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, @@ -143,7 +156,6 @@ basicKnownKeyNames -- Enum stuff enumFromName, enumFromThenName, enumFromThenToName, enumFromToName, - enumFromToPName, enumFromThenToPName, -- Monad stuff thenIOName, bindIOName, returnIOName, failIOName, @@ -164,12 +176,12 @@ basicKnownKeyNames -- Read stuff readClassName, - + -- Stable pointers newStablePtrName, -- GHC Extensions - groupWithName, + groupWithName, -- Strings and lists unpackCStringName, unpackCStringAppendName, @@ -179,10 +191,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, @@ -203,9 +212,9 @@ basicKnownKeyNames -- Other classes randomClassName, randomGenClassName, monadPlusClassName, - -- Booleans - andName, orName - + -- Annotation type checking + toAnnotationWrapperName + -- The Either type , eitherTyConName, leftDataConName, rightDataConName @@ -216,6 +225,20 @@ basicKnownKeyNames 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} @@ -231,31 +254,43 @@ genericTyConNames = [crossTyConName, plusTyConName, genUnitTyConName] pRELUDE :: Module pRELUDE = mkBaseModule_ pRELUDE_NAME -gHC_PRIM, gHC_BOOL, gHC_ORDERING, gHC_GENERICS, gHC_BASE, gHC_ENUM, - gHC_SHOW, gHC_READ, gHC_NUM, gHC_INTEGER, gHC_LIST, gHC_PARR, - dATA_TUP, dATA_EITHER, dATA_STRING, gHC_PACK, gHC_CONC, gHC_IO_BASE, +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_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_FLOAT, gHC_TOP_HANDLER, sYSTEM_IO, dYNAMIC, tYPEABLE, gENERICS, - dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW, - gHC_DESUGAR, rANDOM, gHC_EXTS :: Module + dOTNET, rEAD_PREC, lEX, gHC_INT, gHC_WORD, mONAD, mONAD_FIX, aRROW, cONTROL_APPLICATIVE, + gHC_DESUGAR, rANDOM, gHC_EXTS, cONTROL_EXCEPTION_BASE :: Module + gHC_PRIM = mkPrimModule (fsLit "GHC.Prim") -- Primitive types and values -gHC_BOOL = mkPrimModule (fsLit "GHC.Bool") +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_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_LIST = mkBaseModule (fsLit "GHC.List") -gHC_PARR = mkBaseModule (fsLit "GHC.PArr") -dATA_TUP = mkBaseModule (fsLit "Data.Tuple") +gHC_INTEGER_TYPE= mkIntegerModule (fsLit "GHC.Integer.Type") +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_PACK = mkBaseModule (fsLit "GHC.Pack") gHC_CONC = mkBaseModule (fsLit "GHC.Conc") -gHC_IO_BASE = mkBaseModule (fsLit "GHC.IOBase") +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") @@ -268,18 +303,26 @@ 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") +gENERICS = mkBaseModule (fsLit "Data.Data") dOTNET = mkBaseModule (fsLit "GHC.Dotnet") rEAD_PREC = mkBaseModule (fsLit "Text.ParserCombinators.ReadPrec") -lEX = mkBaseModule (fsLit "Text.Read.Lex") +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") +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 @@ -289,9 +332,8 @@ rOOT_MAIN = mkMainModule (fsLit ":Main") -- Root module for initialisation -- 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, thFAKE :: Module +iNTERACTIVE :: Module iNTERACTIVE = mkMainModule (fsLit ":Interactive") -thFAKE = mkMainModule (fsLit ":THFake") pRELUDE_NAME, mAIN_NAME :: ModuleName pRELUDE_NAME = mkModuleNameFS (fsLit "Prelude") @@ -324,8 +366,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} @@ -350,11 +392,11 @@ 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") +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") @@ -378,9 +420,6 @@ returnM_RDR = nameRdrName returnMName bindM_RDR = nameRdrName bindMName failM_RDR = nameRdrName failMName -and_RDR :: RdrName -and_RDR = nameRdrName andName - left_RDR, right_RDR :: RdrName left_RDR = nameRdrName leftDataConName right_RDR = nameRdrName rightDataConName @@ -432,9 +471,10 @@ compose_RDR :: RdrName compose_RDR = varQual_RDR gHC_BASE (fsLit ".") not_RDR, getTag_RDR, succ_RDR, pred_RDR, minBound_RDR, maxBound_RDR, - range_RDR, inRange_RDR, index_RDR, + and_RDR, range_RDR, inRange_RDR, index_RDR, unsafeIndex_RDR, unsafeRangeSize_RDR :: RdrName -not_RDR = varQual_RDR gHC_BASE (fsLit "not") +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") @@ -491,6 +531,13 @@ inlDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inl") inrDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Inr") genUnitDataCon_RDR = dataQual_RDR gHC_GENERICS (fsLit "Unit") +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 @@ -515,6 +562,9 @@ and it's convenient to write them all down in one place. \begin{code} +wildCardName :: Name +wildCardName = mkSystemVarName wildCardKey (fsLit "wild") + runMainIOName :: Name runMainIOName = varQual gHC_TOP_HANDLER (fsLit "runMainIO") runMainKey @@ -544,14 +594,14 @@ stringTyConName = tcQual gHC_BASE (fsLit "String") stringTyConKey -- The 'inline' function inlineIdName :: Name -inlineIdName = varQual gHC_BASE (fsLit "inline") inlineIdKey +inlineIdName = varQual gHC_MAGIC (fsLit "inline") inlineIdKey -- Base classes (Eq, Ord, Functor) eqClassName, eqName, ordClassName, geName, functorClassName :: Name -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 +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 -- Class Monad @@ -562,24 +612,29 @@ 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 :: Name groupWithName = varQual gHC_EXTS (fsLit "groupWith") groupWithIdKey -- Random PrelBase functions fromStringName, otherwiseIdName, foldrName, buildName, augmentName, - mapName, appendName, andName, orName, assertName, + mapName, appendName, assertName, breakpointName, breakpointCondName, breakpointAutoName, - opaqueTyConName :: Name + 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 +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 +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 @@ -607,25 +662,27 @@ breakpointAutoJumpName -- PrelTup fstName, sndName :: Name -fstName = varQual dATA_TUP (fsLit "fst") fstIdKey -sndName = varQual dATA_TUP (fsLit "snd") sndIdKey +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 + 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 (fsLit "Integer") integerTyConKey +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 @@ -633,7 +690,11 @@ 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 +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 @@ -668,7 +729,7 @@ dataClassName = clsQual gENERICS (fsLit "Data") dataClassKey -- Error module assertErrorName :: Name -assertErrorName = varQual gHC_ERR (fsLit "assertError") assertErrorIdKey +assertErrorName = varQual gHC_IO_Exception (fsLit "assertError") assertErrorIdKey -- Enum module (Enum, Bounded) enumClassName, enumFromName, enumFromToName, enumFromThenName, @@ -697,33 +758,32 @@ readClassName = clsQual gHC_READ (fsLit "Read") readClassKey -- parallel array types and functions enumFromToPName, enumFromThenToPName, nullPName, lengthPName, singletonPName, replicatePName, mapPName, filterPName, - zipPName, crossMapPName, indexPName, toPName, bpermutePName, - bpermuteDftPName, indexOfPName :: 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 -bpermutePName = varQual gHC_PARR (fsLit "bpermuteP") bpermutePIdKey -bpermuteDftPName = varQual gHC_PARR (fsLit "bpermuteDftP") bpermuteDftPIdKey -indexOfPName = varQual gHC_PARR (fsLit "indexOfP") indexOfPIdKey - --- IOBase things + 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 + +-- IO things ioTyConName, ioDataConName, thenIOName, bindIOName, returnIOName, failIOName :: Name -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 +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 @@ -774,6 +834,10 @@ appAName = varQual aRROW (fsLit "app") appAIdKey choiceAName = varQual aRROW (fsLit "|||") choiceAIdKey loopAName = varQual aRROW (fsLit "loop") loopAIdKey +-- Annotation type checking +toAnnotationWrapperName :: Name +toAnnotationWrapperName = varQual gHC_DESUGAR (fsLit "toAnnotationWrapper") toAnnotationWrapperIdKey + -- Other classes, needed for type defaulting monadPlusClassName, randomClassName, randomGenClassName, isStringClassName :: Name @@ -875,6 +939,11 @@ randomGenClassKey = mkPreludeClassUnique 32 isStringClassKey :: Unique isStringClassKey = mkPreludeClassUnique 33 + +applicativeClassKey, foldableClassKey, traversableClassKey :: Unique +applicativeClassKey = mkPreludeClassUnique 34 +foldableClassKey = mkPreludeClassUnique 35 +traversableClassKey = mkPreludeClassUnique 36 \end{code} %************************************************************************ @@ -892,7 +961,8 @@ addrPrimTyConKey, arrayPrimTyConKey, boolTyConKey, byteArrayPrimTyConKey, listTyConKey, foreignObjPrimTyConKey, weakPrimTyConKey, mutableArrayPrimTyConKey, mutableByteArrayPrimTyConKey, orderingTyConKey, mVarPrimTyConKey, ratioTyConKey, rationalTyConKey, - realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey :: Unique + realWorldTyConKey, stablePtrPrimTyConKey, stablePtrTyConKey, + anyTyConKey :: Unique addrPrimTyConKey = mkPreludeTyConUnique 1 arrayPrimTyConKey = mkPreludeTyConUnique 3 boolTyConKey = mkPreludeTyConUnique 4 @@ -925,10 +995,7 @@ rationalTyConKey = mkPreludeTyConUnique 33 realWorldTyConKey = mkPreludeTyConUnique 34 stablePtrPrimTyConKey = mkPreludeTyConUnique 35 stablePtrTyConKey = mkPreludeTyConUnique 36 - -anyPrimTyConKey, anyPrimTyCon1Key :: Unique -anyPrimTyConKey = mkPreludeTyConUnique 37 -anyPrimTyCon1Key = mkPreludeTyConUnique 38 +anyTyConKey = mkPreludeTyConUnique 37 statePrimTyConKey, stableNamePrimTyConKey, stableNameTyConKey, mutVarPrimTyConKey, ioTyConKey, @@ -995,7 +1062,8 @@ argTypeKindTyConKey = mkPreludeTyConUnique 91 -- Coercion constructors symCoercionTyConKey, transCoercionTyConKey, leftCoercionTyConKey, - rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey + rightCoercionTyConKey, instCoercionTyConKey, unsafeCoercionTyConKey, + csel1CoercionTyConKey, csel2CoercionTyConKey, cselRCoercionTyConKey :: Unique symCoercionTyConKey = mkPreludeTyConUnique 93 transCoercionTyConKey = mkPreludeTyConUnique 94 @@ -1003,10 +1071,13 @@ leftCoercionTyConKey = mkPreludeTyConUnique 95 rightCoercionTyConKey = mkPreludeTyConUnique 96 instCoercionTyConKey = mkPreludeTyConUnique 97 unsafeCoercionTyConKey = mkPreludeTyConUnique 98 +csel1CoercionTyConKey = mkPreludeTyConUnique 99 +csel2CoercionTyConKey = mkPreludeTyConUnique 100 +cselRCoercionTyConKey = mkPreludeTyConUnique 101 unknownTyConKey, unknown1TyConKey, unknown2TyConKey, unknown3TyConKey, opaqueTyConKey :: Unique -unknownTyConKey = mkPreludeTyConUnique 99 +unknownTyConKey = mkPreludeTyConUnique 129 unknown1TyConKey = mkPreludeTyConUnique 130 unknown2TyConKey = mkPreludeTyConUnique 131 unknown3TyConKey = mkPreludeTyConUnique 132 @@ -1033,7 +1104,7 @@ unitTyConKey = mkTupleTyConUnique Boxed 0 charDataConKey, consDataConKey, doubleDataConKey, falseDataConKey, floatDataConKey, intDataConKey, nilDataConKey, ratioDataConKey, stableNameDataConKey, trueDataConKey, wordDataConKey, - ioDataConKey :: Unique + ioDataConKey, integerDataConKey :: Unique charDataConKey = mkPreludeDataConUnique 1 consDataConKey = mkPreludeDataConUnique 2 doubleDataConKey = mkPreludeDataConUnique 3 @@ -1046,6 +1117,7 @@ stableNameDataConKey = mkPreludeDataConUnique 14 trueDataConKey = mkPreludeDataConUnique 15 wordDataConKey = mkPreludeDataConUnique 16 ioDataConKey = mkPreludeDataConUnique 17 +integerDataConKey = mkPreludeDataConUnique 18 -- Generic data constructors crossDataConKey, inlDataConKey, inrDataConKey, genUnitDataConKey :: Unique @@ -1071,17 +1143,18 @@ rightDataConKey = mkPreludeDataConUnique 26 \begin{code} absentErrorIdKey, augmentIdKey, appendIdKey, buildIdKey, errorIdKey, - foldlIdKey, foldrIdKey, recSelErrorIdKey, + foldlIdKey, foldrIdKey, recSelErrorIdKey, integerMinusOneIdKey, integerPlusOneIdKey, integerPlusTwoIdKey, integerZeroIdKey, int2IntegerIdKey, seqIdKey, irrefutPatErrorIdKey, eqStringIdKey, 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 @@ -1142,9 +1215,7 @@ rootMainKey, runMainKey :: Unique rootMainKey = mkPreludeMiscIdUnique 55 runMainKey = mkPreludeMiscIdUnique 56 -andIdKey, orIdKey, thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique -andIdKey = mkPreludeMiscIdUnique 57 -orIdKey = mkPreludeMiscIdUnique 58 +thenIOIdKey, lazyIdKey, assertErrorIdKey :: Unique thenIOIdKey = mkPreludeMiscIdUnique 59 lazyIdKey = mkPreludeMiscIdUnique 60 assertErrorIdKey = mkPreludeMiscIdUnique 61 @@ -1162,15 +1233,15 @@ breakpointAutoJumpIdKey = mkPreludeMiscIdUnique 67 inlineIdKey :: Unique inlineIdKey = mkPreludeMiscIdUnique 68 -mapIdKey, groupWithIdKey :: Unique -mapIdKey = mkPreludeMiscIdUnique 69 +mapIdKey, groupWithIdKey, dollarIdKey :: Unique +mapIdKey = mkPreludeMiscIdUnique 69 groupWithIdKey = mkPreludeMiscIdUnique 70 +dollarIdKey = mkPreludeMiscIdUnique 71 -- Parallel array functions singletonPIdKey, nullPIdKey, lengthPIdKey, replicatePIdKey, mapPIdKey, filterPIdKey, zipPIdKey, crossMapPIdKey, indexPIdKey, toPIdKey, - enumFromToPIdKey, enumFromThenToPIdKey, - bpermutePIdKey, bpermuteDftPIdKey, indexOfPIdKey :: Unique + enumFromToPIdKey, enumFromThenToPIdKey, emptyPIdKey, appPIdKey :: Unique singletonPIdKey = mkPreludeMiscIdUnique 79 nullPIdKey = mkPreludeMiscIdUnique 80 lengthPIdKey = mkPreludeMiscIdUnique 81 @@ -1183,9 +1254,8 @@ 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, @@ -1244,6 +1314,17 @@ 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 + ---------------- Template Haskell ------------------- -- USES IdUniques 200-399 ----------------------------------------------------- @@ -1265,6 +1346,13 @@ numericTyKeys = , doubleTyConKey , floatTyConKey ] + +kindKeys :: [Unique] +kindKeys = [ liftedTypeKindTyConKey + , openTypeKindTyConKey + , unliftedTypeKindTyConKey + , ubxTupleKindTyConKey + , argTypeKindTyConKey ] \end{code} @@ -1309,7 +1397,8 @@ standardClassKeys = derivableClassKeys ++ numericClassKeys ++ [randomClassKey, randomGenClassKey, functorClassKey, monadClassKey, monadPlusClassKey, - isStringClassKey + isStringClassKey, + applicativeClassKey, foldableClassKey, traversableClassKey ] \end{code}