compiler/prelude/TysPrim.lhs

   1 %
   2 % (c) The AQUA Project, Glasgow University, 1994-1998
   3 %
   4 \section[TysPrim]{Wired-in knowledge about primitive types}
   5
   6 \begin{code}
   7 module TysPrim(
   8         alphaTyVars, betaTyVars, alphaTyVar, betaTyVar, gammaTyVar, deltaTyVar,
   9         alphaTy, betaTy, gammaTy, deltaTy,
  10         openAlphaTy, openBetaTy, openAlphaTyVar, openBetaTyVar, openAlphaTyVars,
  11
  12         primTyCons,
  13
  14         charPrimTyCon,          charPrimTy,
  15         intPrimTyCon,           intPrimTy,
  16         wordPrimTyCon,          wordPrimTy,
  17         addrPrimTyCon,          addrPrimTy,
  18         floatPrimTyCon,         floatPrimTy,
  19         doublePrimTyCon,        doublePrimTy,
  20
  21         statePrimTyCon,         mkStatePrimTy,
  22         realWorldTyCon,         realWorldTy, realWorldStatePrimTy,
  23
  24         arrayPrimTyCon,                 mkArrayPrimTy,
  25         byteArrayPrimTyCon,             byteArrayPrimTy,
  26         mutableArrayPrimTyCon,          mkMutableArrayPrimTy,
  27         mutableByteArrayPrimTyCon,      mkMutableByteArrayPrimTy,
  28         mutVarPrimTyCon,                mkMutVarPrimTy,
  29
  30         mVarPrimTyCon,                  mkMVarPrimTy,
  31         tVarPrimTyCon,                  mkTVarPrimTy,
  32         stablePtrPrimTyCon,             mkStablePtrPrimTy,
  33         stableNamePrimTyCon,            mkStableNamePrimTy,
  34         bcoPrimTyCon,                   bcoPrimTy,
  35         weakPrimTyCon,                  mkWeakPrimTy,
  36         threadIdPrimTyCon,              threadIdPrimTy,
  37
  38         int32PrimTyCon,         int32PrimTy,
  39         word32PrimTyCon,        word32PrimTy,
  40
  41         int64PrimTyCon,         int64PrimTy,
  42         word64PrimTyCon,        word64PrimTy,
  43
  44         anyPrimTyCon, anyPrimTy, anyPrimTyCon1, mkAnyPrimTyCon
  45   ) where
  46
  47 #include "HsVersions.h"
  48
  49 import Var              ( TyVar, mkTyVar )
  50 import Name             ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
  51 import OccName          ( mkOccNameFS, tcName, mkTyVarOcc )
  52 import TyCon            ( TyCon, mkPrimTyCon, mkLiftedPrimTyCon,
  53                           PrimRep(..) )
  54 import Type             ( mkTyConApp, mkTyConTy, mkTyVarTys, mkTyVarTy,
  55                           unliftedTypeKind,
  56                           liftedTypeKind, openTypeKind,
  57                           Kind, mkArrowKinds, mkArrowKind,
  58                           TyThing(..)
  59                         )
  60 import SrcLoc
  61 import Unique           ( mkAlphaTyVarUnique, pprUnique )
  62 import PrelNames
  63 import FastString       ( FastString, mkFastString )
  64 import Outputable
  65
  66 import Char             ( ord, chr )
  67 \end{code}
  68
  69 %************************************************************************
  70 %*                                                                      *
  71 \subsection{Primitive type constructors}
  72 %*                                                                      *
  73 %************************************************************************
  74
  75 \begin{code}
  76 primTyCons :: [TyCon]
  77 primTyCons
  78   = [ addrPrimTyCon
  79     , arrayPrimTyCon
  80     , byteArrayPrimTyCon
  81     , charPrimTyCon
  82     , doublePrimTyCon
  83     , floatPrimTyCon
  84     , intPrimTyCon
  85     , int32PrimTyCon
  86     , int64PrimTyCon
  87     , bcoPrimTyCon
  88     , weakPrimTyCon
  89     , mutableArrayPrimTyCon
  90     , mutableByteArrayPrimTyCon
  91     , mVarPrimTyCon
  92     , tVarPrimTyCon
  93     , mutVarPrimTyCon
  94     , realWorldTyCon
  95     , stablePtrPrimTyCon
  96     , stableNamePrimTyCon
  97     , statePrimTyCon
  98     , threadIdPrimTyCon
  99     , wordPrimTyCon
 100     , word32PrimTyCon
 101     , word64PrimTyCon
 102     , anyPrimTyCon, anyPrimTyCon1
 103     ]
 104
 105 mkPrimTc :: FastString -> Unique -> TyCon -> Name
 106 mkPrimTc fs uniq tycon
 107   = mkWiredInName gHC_PRIM (mkOccNameFS tcName fs)
 108                   uniq
 109                   (ATyCon tycon)        -- Relevant TyCon
 110                   UserSyntax            -- None are built-in syntax
 111
 112 charPrimTyConName             = mkPrimTc FSLIT("Char#") charPrimTyConKey charPrimTyCon
 113 intPrimTyConName              = mkPrimTc FSLIT("Int#") intPrimTyConKey  intPrimTyCon
 114 int32PrimTyConName            = mkPrimTc FSLIT("Int32#") int32PrimTyConKey int32PrimTyCon
 115 int64PrimTyConName            = mkPrimTc FSLIT("Int64#") int64PrimTyConKey int64PrimTyCon
 116 wordPrimTyConName             = mkPrimTc FSLIT("Word#") wordPrimTyConKey wordPrimTyCon
 117 word32PrimTyConName           = mkPrimTc FSLIT("Word32#") word32PrimTyConKey word32PrimTyCon
 118 word64PrimTyConName           = mkPrimTc FSLIT("Word64#") word64PrimTyConKey word64PrimTyCon
 119 addrPrimTyConName             = mkPrimTc FSLIT("Addr#") addrPrimTyConKey addrPrimTyCon
 120 floatPrimTyConName            = mkPrimTc FSLIT("Float#") floatPrimTyConKey floatPrimTyCon
 121 doublePrimTyConName           = mkPrimTc FSLIT("Double#") doublePrimTyConKey doublePrimTyCon
 122 statePrimTyConName            = mkPrimTc FSLIT("State#") statePrimTyConKey statePrimTyCon
 123 realWorldTyConName            = mkPrimTc FSLIT("RealWorld") realWorldTyConKey realWorldTyCon
 124 arrayPrimTyConName            = mkPrimTc FSLIT("Array#") arrayPrimTyConKey arrayPrimTyCon
 125 byteArrayPrimTyConName        = mkPrimTc FSLIT("ByteArray#") byteArrayPrimTyConKey byteArrayPrimTyCon
 126 mutableArrayPrimTyConName     = mkPrimTc FSLIT("MutableArray#") mutableArrayPrimTyConKey mutableArrayPrimTyCon
 127 mutableByteArrayPrimTyConName = mkPrimTc FSLIT("MutableByteArray#") mutableByteArrayPrimTyConKey mutableByteArrayPrimTyCon
 128 mutVarPrimTyConName           = mkPrimTc FSLIT("MutVar#") mutVarPrimTyConKey mutVarPrimTyCon
 129 mVarPrimTyConName             = mkPrimTc FSLIT("MVar#") mVarPrimTyConKey mVarPrimTyCon
 130 tVarPrimTyConName             = mkPrimTc FSLIT("TVar#") tVarPrimTyConKey tVarPrimTyCon
 131 stablePtrPrimTyConName        = mkPrimTc FSLIT("StablePtr#") stablePtrPrimTyConKey stablePtrPrimTyCon
 132 stableNamePrimTyConName       = mkPrimTc FSLIT("StableName#") stableNamePrimTyConKey stableNamePrimTyCon
 133 bcoPrimTyConName              = mkPrimTc FSLIT("BCO#") bcoPrimTyConKey bcoPrimTyCon
 134 weakPrimTyConName             = mkPrimTc FSLIT("Weak#") weakPrimTyConKey weakPrimTyCon
 135 threadIdPrimTyConName         = mkPrimTc FSLIT("ThreadId#") threadIdPrimTyConKey threadIdPrimTyCon
 136 anyPrimTyConName              = mkPrimTc FSLIT("Any") anyPrimTyConKey anyPrimTyCon
 137 anyPrimTyCon1Name             = mkPrimTc FSLIT("Any1") anyPrimTyCon1Key anyPrimTyCon
 138 \end{code}
 139
 140 %************************************************************************
 141 %*                                                                      *
 142 \subsection{Support code}
 143 %*                                                                      *
 144 %************************************************************************
 145
 146 alphaTyVars is a list of type variables for use in templates:
 147         ["a", "b", ..., "z", "t1", "t2", ... ]
 148
 149 \begin{code}
 150 tyVarList :: Kind -> [TyVar]
 151 tyVarList kind = [ mkTyVar (mkInternalName (mkAlphaTyVarUnique u)
 152                                 (mkTyVarOcc (mkFastString name))
 153                                 noSrcSpan) kind
 154                  | u <- [2..],
 155                    let name | c <= 'z'  = [c]
 156                             | otherwise = 't':show u
 157                             where c = chr (u-2 + ord 'a')
 158                  ]
 159
 160 alphaTyVars :: [TyVar]
 161 alphaTyVars = tyVarList liftedTypeKind
 162
 163 betaTyVars = tail alphaTyVars
 164
 165 alphaTyVar, betaTyVar, gammaTyVar :: TyVar
 166 (alphaTyVar:betaTyVar:gammaTyVar:deltaTyVar:_) = alphaTyVars
 167
 168 alphaTys = mkTyVarTys alphaTyVars
 169 (alphaTy:betaTy:gammaTy:deltaTy:_) = alphaTys
 170
 171         -- openAlphaTyVar is prepared to be instantiated
 172         -- to a lifted or unlifted type variable.  It's used for the
 173         -- result type for "error", so that we can have (error Int# "Help")
 174 openAlphaTyVars :: [TyVar]
 175 openAlphaTyVars@(openAlphaTyVar:openBetaTyVar:_) = tyVarList openTypeKind
 176
 177 openAlphaTy = mkTyVarTy openAlphaTyVar
 178 openBetaTy   = mkTyVarTy openBetaTyVar
 179 \end{code}
 180
 181
 182 %************************************************************************
 183 %*                                                                      *
 184 \subsection[TysPrim-basic]{Basic primitive types (@Char#@, @Int#@, etc.)}
 185 %*                                                                      *
 186 %************************************************************************
 187
 188 \begin{code}
 189 -- only used herein
 190 pcPrimTyCon :: Name -> Int -> PrimRep -> TyCon
 191 pcPrimTyCon name arity rep
 192   = mkPrimTyCon name kind arity rep
 193   where
 194     kind        = mkArrowKinds (replicate arity liftedTypeKind) result_kind
 195     result_kind = unliftedTypeKind
 196
 197 pcPrimTyCon0 :: Name -> PrimRep -> TyCon
 198 pcPrimTyCon0 name rep
 199   = mkPrimTyCon name result_kind 0 rep
 200   where
 201     result_kind = unliftedTypeKind
 202
 203 charPrimTy      = mkTyConTy charPrimTyCon
 204 charPrimTyCon   = pcPrimTyCon0 charPrimTyConName WordRep
 205
 206 intPrimTy       = mkTyConTy intPrimTyCon
 207 intPrimTyCon    = pcPrimTyCon0 intPrimTyConName IntRep
 208
 209 int32PrimTy     = mkTyConTy int32PrimTyCon
 210 int32PrimTyCon  = pcPrimTyCon0 int32PrimTyConName IntRep
 211
 212 int64PrimTy     = mkTyConTy int64PrimTyCon
 213 int64PrimTyCon  = pcPrimTyCon0 int64PrimTyConName Int64Rep
 214
 215 wordPrimTy      = mkTyConTy wordPrimTyCon
 216 wordPrimTyCon   = pcPrimTyCon0 wordPrimTyConName WordRep
 217
 218 word32PrimTy    = mkTyConTy word32PrimTyCon
 219 word32PrimTyCon = pcPrimTyCon0 word32PrimTyConName WordRep
 220
 221 word64PrimTy    = mkTyConTy word64PrimTyCon
 222 word64PrimTyCon = pcPrimTyCon0 word64PrimTyConName Word64Rep
 223
 224 addrPrimTy      = mkTyConTy addrPrimTyCon
 225 addrPrimTyCon   = pcPrimTyCon0 addrPrimTyConName AddrRep
 226
 227 floatPrimTy     = mkTyConTy floatPrimTyCon
 228 floatPrimTyCon  = pcPrimTyCon0 floatPrimTyConName FloatRep
 229
 230 doublePrimTy    = mkTyConTy doublePrimTyCon
 231 doublePrimTyCon = pcPrimTyCon0 doublePrimTyConName DoubleRep
 232 \end{code}
 233
 234
 235 %************************************************************************
 236 %*                                                                      *
 237 \subsection[TysPrim-state]{The @State#@ type (and @_RealWorld@ types)}
 238 %*                                                                      *
 239 %************************************************************************
 240
 241 State# is the primitive, unlifted type of states.  It has one type parameter,
 242 thus
 243         State# RealWorld
 244 or
 245         State# s
 246
 247 where s is a type variable. The only purpose of the type parameter is to
 248 keep different state threads separate.  It is represented by nothing at all.
 249
 250 \begin{code}
 251 mkStatePrimTy ty = mkTyConApp statePrimTyCon [ty]
 252 statePrimTyCon   = pcPrimTyCon statePrimTyConName 1 VoidRep
 253 \end{code}
 254
 255 RealWorld is deeply magical.  It is *primitive*, but it is not
 256 *unlifted* (hence ptrArg).  We never manipulate values of type
 257 RealWorld; it's only used in the type system, to parameterise State#.
 258
 259 \begin{code}
 260 realWorldTyCon = mkLiftedPrimTyCon realWorldTyConName liftedTypeKind 0 PtrRep
 261 realWorldTy          = mkTyConTy realWorldTyCon
 262 realWorldStatePrimTy = mkStatePrimTy realWorldTy        -- State# RealWorld
 263 \end{code}
 264
 265 Note: the ``state-pairing'' types are not truly primitive, so they are
 266 defined in \tr{TysWiredIn.lhs}, not here.
 267
 268
 269 %************************************************************************
 270 %*                                                                      *
 271                 Any
 272 %*                                                                      *
 273 %************************************************************************
 274
 275 The type constructor Any is type to which you can unsafely coerce any
 276 lifted type, and back.
 277
 278   * It is lifted, and hence represented by a pointer
 279
 280   * It does not claim to be a *data* type, and that's important for
 281     the code generator, because the code gen may *enter* a data value
 282     but never enters a function value.
 283
 284 It's also used to instantiate un-constrained type variables after type
 285 checking.  For example
 286         lenth Any []
 287 Annoyingly, we sometimes need Anys of other kinds, such as (*->*) etc.
 288 This is a bit like tuples.   We define a couple of useful ones here,
 289 and make others up on the fly.  If any of these others end up being exported
 290 into interface files, we'll get a crash; at least until we add interface-file
 291 syntax to support them.
 292
 293 \begin{code}
 294 anyPrimTy = mkTyConApp anyPrimTyCon []
 295
 296 anyPrimTyCon :: TyCon   -- Kind *
 297 anyPrimTyCon = mkLiftedPrimTyCon anyPrimTyConName liftedTypeKind 0 PtrRep
 298
 299 anyPrimTyCon1 :: TyCon  -- Kind *->*
 300 anyPrimTyCon1 = mkLiftedPrimTyCon anyPrimTyCon1Name kind 0 PtrRep
 301   where
 302     kind = mkArrowKind liftedTypeKind liftedTypeKind
 303
 304 mkAnyPrimTyCon :: Unique -> Kind -> TyCon
 305 -- Grotesque hack alert: the client gives the unique; so equality won't work
 306 mkAnyPrimTyCon uniq kind
 307   = pprTrace "Urk! Inventing strangely-kinded Any TyCon:" (ppr uniq <+> ppr kind)
 308     tycon
 309   where
 310      name  = mkPrimTc (mkFastString ("Any" ++ showSDoc (pprUnique uniq))) uniq tycon
 311      tycon = mkLiftedPrimTyCon name kind 0 PtrRep
 312 \end{code}
 313
 314
 315 %************************************************************************
 316 %*                                                                      *
 317 \subsection[TysPrim-arrays]{The primitive array types}
 318 %*                                                                      *
 319 %************************************************************************
 320
 321 \begin{code}
 322 arrayPrimTyCon            = pcPrimTyCon  arrayPrimTyConName            1 PtrRep
 323 mutableArrayPrimTyCon     = pcPrimTyCon  mutableArrayPrimTyConName     2 PtrRep
 324 mutableByteArrayPrimTyCon = pcPrimTyCon  mutableByteArrayPrimTyConName 1 PtrRep
 325 byteArrayPrimTyCon        = pcPrimTyCon0 byteArrayPrimTyConName          PtrRep
 326
 327 mkArrayPrimTy elt           = mkTyConApp arrayPrimTyCon [elt]
 328 byteArrayPrimTy             = mkTyConTy byteArrayPrimTyCon
 329 mkMutableArrayPrimTy s elt  = mkTyConApp mutableArrayPrimTyCon [s, elt]
 330 mkMutableByteArrayPrimTy s  = mkTyConApp mutableByteArrayPrimTyCon [s]
 331 \end{code}
 332
 333 %************************************************************************
 334 %*                                                                      *
 335 \subsection[TysPrim-mut-var]{The mutable variable type}
 336 %*                                                                      *
 337 %************************************************************************
 338
 339 \begin{code}
 340 mutVarPrimTyCon = pcPrimTyCon mutVarPrimTyConName 2 PtrRep
 341
 342 mkMutVarPrimTy s elt        = mkTyConApp mutVarPrimTyCon [s, elt]
 343 \end{code}
 344
 345 %************************************************************************
 346 %*                                                                      *
 347 \subsection[TysPrim-synch-var]{The synchronizing variable type}
 348 %*                                                                      *
 349 %************************************************************************
 350
 351 \begin{code}
 352 mVarPrimTyCon = pcPrimTyCon mVarPrimTyConName 2 PtrRep
 353
 354 mkMVarPrimTy s elt          = mkTyConApp mVarPrimTyCon [s, elt]
 355 \end{code}
 356
 357 %************************************************************************
 358 %*                                                                      *
 359 \subsection[TysPrim-stm-var]{The transactional variable type}
 360 %*                                                                      *
 361 %************************************************************************
 362
 363 \begin{code}
 364 tVarPrimTyCon = pcPrimTyCon tVarPrimTyConName 2 PtrRep
 365
 366 mkTVarPrimTy s elt          = mkTyConApp tVarPrimTyCon [s, elt]
 367 \end{code}
 368
 369 %************************************************************************
 370 %*                                                                      *
 371 \subsection[TysPrim-stable-ptrs]{The stable-pointer type}
 372 %*                                                                      *
 373 %************************************************************************
 374
 375 \begin{code}
 376 stablePtrPrimTyCon = pcPrimTyCon stablePtrPrimTyConName 1 AddrRep
 377
 378 mkStablePtrPrimTy ty = mkTyConApp stablePtrPrimTyCon [ty]
 379 \end{code}
 380
 381 %************************************************************************
 382 %*                                                                      *
 383 \subsection[TysPrim-stable-names]{The stable-name type}
 384 %*                                                                      *
 385 %************************************************************************
 386
 387 \begin{code}
 388 stableNamePrimTyCon = pcPrimTyCon stableNamePrimTyConName 1 PtrRep
 389
 390 mkStableNamePrimTy ty = mkTyConApp stableNamePrimTyCon [ty]
 391 \end{code}
 392
 393 %************************************************************************
 394 %*                                                                      *
 395 \subsection[TysPrim-BCOs]{The ``bytecode object'' type}
 396 %*                                                                      *
 397 %************************************************************************
 398
 399 \begin{code}
 400 bcoPrimTy    = mkTyConTy bcoPrimTyCon
 401 bcoPrimTyCon = pcPrimTyCon0 bcoPrimTyConName PtrRep
 402 \end{code}
 403
 404 %************************************************************************
 405 %*                                                                      *
 406 \subsection[TysPrim-Weak]{The ``weak pointer'' type}
 407 %*                                                                      *
 408 %************************************************************************
 409
 410 \begin{code}
 411 weakPrimTyCon = pcPrimTyCon weakPrimTyConName 1 PtrRep
 412
 413 mkWeakPrimTy v = mkTyConApp weakPrimTyCon [v]
 414 \end{code}
 415
 416 %************************************************************************
 417 %*                                                                      *
 418 \subsection[TysPrim-thread-ids]{The ``thread id'' type}
 419 %*                                                                      *
 420 %************************************************************************
 421
 422 A thread id is represented by a pointer to the TSO itself, to ensure
 423 that they are always unique and we can always find the TSO for a given
 424 thread id.  However, this has the unfortunate consequence that a
 425 ThreadId# for a given thread is treated as a root by the garbage
 426 collector and can keep TSOs around for too long.
 427
 428 Hence the programmer API for thread manipulation uses a weak pointer
 429 to the thread id internally.
 430
 431 \begin{code}
 432 threadIdPrimTy    = mkTyConTy threadIdPrimTyCon
 433 threadIdPrimTyCon = pcPrimTyCon0 threadIdPrimTyConName PtrRep
 434 \end{code}