{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1998

-}

{-# LANGUAGE DeriveDataTypeable, ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE AllowAmbiguousTypes #-}

{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}

-- | Core literals
module GHC.Types.Literal
        (
        -- * Main data type
          Literal(..)           -- Exported to ParseIface
        , LitNumType(..)

        -- ** Creating Literals
        , mkLitInt, mkLitIntWrap, mkLitIntWrapC, mkLitIntUnchecked
        , mkLitWord, mkLitWordWrap, mkLitWordWrapC, mkLitWordUnchecked
        , mkLitInt8, mkLitInt8Wrap, mkLitInt8Unchecked
        , mkLitWord8, mkLitWord8Wrap, mkLitWord8Unchecked
        , mkLitInt16, mkLitInt16Wrap, mkLitInt16Unchecked
        , mkLitWord16, mkLitWord16Wrap, mkLitWord16Unchecked
        , mkLitInt32, mkLitInt32Wrap, mkLitInt32Unchecked
        , mkLitWord32, mkLitWord32Wrap, mkLitWord32Unchecked
        , mkLitInt64, mkLitInt64Wrap, mkLitInt64Unchecked
        , mkLitWord64, mkLitWord64Wrap, mkLitWord64Unchecked
        , mkLitFloat, mkLitDouble
        , mkLitChar, mkLitString
        , mkLitBigNat
        , mkLitNumber, mkLitNumberWrap

        -- ** Operations on Literals
        , literalType
        , pprLiteral
        , litNumIsSigned
        , litNumRange
        , litNumCheckRange
        , litNumWrap
        , litNumCoerce
        , litNumNarrow
        , litNumBitSize
        , isMinBound
        , isMaxBound

        -- ** Predicates on Literals and their contents
        , litIsDupable, litIsTrivial, litIsLifted
        , inCharRange
        , isZeroLit, isOneLit
        , litFitsInChar
        , litValue, mapLitValue
        , isLitValue_maybe, isLitRubbish

        -- ** Coercions
        , narrowInt8Lit, narrowInt16Lit, narrowInt32Lit, narrowInt64Lit
        , narrowWord8Lit, narrowWord16Lit, narrowWord32Lit, narrowWord64Lit
        , convertToIntLit, convertToWordLit
        , charToIntLit, intToCharLit
        , floatToIntLit, intToFloatLit, doubleToIntLit, intToDoubleLit
        , nullAddrLit, floatToDoubleLit, doubleToFloatLit
        ) where

import GHC.Prelude

import GHC.Builtin.Types.Prim
import GHC.Core.Type( Type, RuntimeRepType, mkForAllTy, mkTyVarTy, typeOrConstraintKind )
import GHC.Core.TyCo.Compare( nonDetCmpType )
import GHC.Types.Var
import GHC.Utils.Outputable
import GHC.Data.FastString
import GHC.Types.Basic
import GHC.Utils.Binary
import GHC.Settings.Constants
import GHC.Platform
import GHC.Utils.Panic
import GHC.Utils.Encoding

import Data.ByteString (ByteString)
import Data.Int
import Data.Word
import Data.Char
import Data.Data ( Data )
import GHC.Exts( isTrue#, dataToTag#, (<#) )
import Numeric ( fromRat )

{-
************************************************************************
*                                                                      *
\subsection{Literals}
*                                                                      *
************************************************************************
-}

-- | So-called 'Literal's are one of:
--
-- * An unboxed numeric literal or floating-point literal which is presumed
--   to be surrounded by appropriate constructors (@Int#@, etc.), so that
--   the overall thing makes sense.
--
--   We maintain the invariant that the 'Integer' in the 'LitNumber'
--   constructor is actually in the (possibly target-dependent) range.
--   The mkLit{Int,Word}*Wrap smart constructors ensure this by applying
--   the target machine's wrapping semantics. Use these in situations
--   where you know the wrapping semantics are correct.
--
-- * The literal derived from the label mentioned in a \"foreign label\"
--   declaration ('LitLabel')
--
-- * A 'LitRubbish' to be used in place of values that are never used.
--
-- * A character
-- * A string
-- * The NULL pointer
--
data Literal
  = LitChar    Char             -- ^ @Char#@ - at least 31 bits. Create with
                                -- 'mkLitChar'

  | LitNumber !LitNumType !Integer
                                -- ^ Any numeric literal that can be
                                -- internally represented with an Integer.

  | LitString !ByteString       -- ^ A string-literal: stored and emitted
                                -- UTF-8 encoded, we'll arrange to decode it
                                -- at runtime.  Also emitted with a @\'\\0\'@
                                -- terminator. Create with 'mkLitString'

  | LitNullAddr                 -- ^ The @NULL@ pointer, the only pointer value
                                -- that can be represented as a Literal. Create
                                -- with 'nullAddrLit'

  | LitRubbish                  -- ^ A nonsense value; See Note [Rubbish literals].
      TypeOrConstraint          -- t_or_c: whether this is a type or a constraint
      RuntimeRepType            -- rr: a type of kind RuntimeRep
      -- The type of the literal is forall (a:TYPE rr). a
      --                         or forall (a:CONSTRAINT rr). a
      --
      -- INVARIANT: the Type has no free variables
      --    and so substitution etc can ignore it

  | LitFloat   Rational         -- ^ @Float#@. Create with 'mkLitFloat'
  | LitDouble  Rational         -- ^ @Double#@. Create with 'mkLitDouble'

  | LitLabel   FastString (Maybe Int) FunctionOrData
                                -- ^ A label literal. Parameters:
                                --
                                -- 1) The name of the symbol mentioned in the
                                --    declaration
                                --
                                -- 2) The size (in bytes) of the arguments
                                --    the label expects. Only applicable with
                                --    @stdcall@ labels. @Just x@ => @\<x\>@ will
                                --    be appended to label name when emitting
                                --    assembly.
                                --
                                -- 3) Flag indicating whether the symbol
                                --    references a function or a data
  deriving Typeable Literal
Typeable Literal =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Literal -> c Literal)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Literal)
-> (Literal -> Constr)
-> (Literal -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Literal))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal))
-> ((forall b. Data b => b -> b) -> Literal -> Literal)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Literal -> r)
-> (forall u. (forall d. Data d => d -> u) -> Literal -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Literal -> m Literal)
-> Data Literal
Literal -> Constr
Literal -> DataType
(forall b. Data b => b -> b) -> Literal -> Literal
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
forall u. (forall d. Data d => d -> u) -> Literal -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Literal -> c Literal
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Literal
$ctoConstr :: Literal -> Constr
toConstr :: Literal -> Constr
$cdataTypeOf :: Literal -> DataType
dataTypeOf :: Literal -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Literal)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Literal)
$cgmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
gmapT :: (forall b. Data b => b -> b) -> Literal -> Literal
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Literal -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Literal -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Literal -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Literal -> m Literal
Data

-- | Numeric literal type
data LitNumType
  = LitNumBigNat  -- ^ @Bignat@ (see Note [BigNum literals])
  | LitNumInt     -- ^ @Int#@ - according to target machine
  | LitNumInt8    -- ^ @Int8#@ - exactly 8 bits
  | LitNumInt16   -- ^ @Int16#@ - exactly 16 bits
  | LitNumInt32   -- ^ @Int32#@ - exactly 32 bits
  | LitNumInt64   -- ^ @Int64#@ - exactly 64 bits
  | LitNumWord    -- ^ @Word#@ - according to target machine
  | LitNumWord8   -- ^ @Word8#@ - exactly 8 bits
  | LitNumWord16  -- ^ @Word16#@ - exactly 16 bits
  | LitNumWord32  -- ^ @Word32#@ - exactly 32 bits
  | LitNumWord64  -- ^ @Word64#@ - exactly 64 bits
  deriving (Typeable LitNumType
Typeable LitNumType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LitNumType -> c LitNumType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LitNumType)
-> (LitNumType -> Constr)
-> (LitNumType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LitNumType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LitNumType))
-> ((forall b. Data b => b -> b) -> LitNumType -> LitNumType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LitNumType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LitNumType -> r)
-> (forall u. (forall d. Data d => d -> u) -> LitNumType -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LitNumType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LitNumType -> m LitNumType)
-> Data LitNumType
LitNumType -> Constr
LitNumType -> DataType
(forall b. Data b => b -> b) -> LitNumType -> LitNumType
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> LitNumType -> u
forall u. (forall d. Data d => d -> u) -> LitNumType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LitNumType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LitNumType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LitNumType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LitNumType -> c LitNumType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LitNumType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LitNumType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LitNumType -> c LitNumType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LitNumType -> c LitNumType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LitNumType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LitNumType
$ctoConstr :: LitNumType -> Constr
toConstr :: LitNumType -> Constr
$cdataTypeOf :: LitNumType -> DataType
dataTypeOf :: LitNumType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LitNumType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LitNumType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LitNumType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LitNumType)
$cgmapT :: (forall b. Data b => b -> b) -> LitNumType -> LitNumType
gmapT :: (forall b. Data b => b -> b) -> LitNumType -> LitNumType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LitNumType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LitNumType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LitNumType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LitNumType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LitNumType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LitNumType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LitNumType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LitNumType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LitNumType -> m LitNumType
Data,Int -> LitNumType
LitNumType -> Int
LitNumType -> [LitNumType]
LitNumType -> LitNumType
LitNumType -> LitNumType -> [LitNumType]
LitNumType -> LitNumType -> LitNumType -> [LitNumType]
(LitNumType -> LitNumType)
-> (LitNumType -> LitNumType)
-> (Int -> LitNumType)
-> (LitNumType -> Int)
-> (LitNumType -> [LitNumType])
-> (LitNumType -> LitNumType -> [LitNumType])
-> (LitNumType -> LitNumType -> [LitNumType])
-> (LitNumType -> LitNumType -> LitNumType -> [LitNumType])
-> Enum LitNumType
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: LitNumType -> LitNumType
succ :: LitNumType -> LitNumType
$cpred :: LitNumType -> LitNumType
pred :: LitNumType -> LitNumType
$ctoEnum :: Int -> LitNumType
toEnum :: Int -> LitNumType
$cfromEnum :: LitNumType -> Int
fromEnum :: LitNumType -> Int
$cenumFrom :: LitNumType -> [LitNumType]
enumFrom :: LitNumType -> [LitNumType]
$cenumFromThen :: LitNumType -> LitNumType -> [LitNumType]
enumFromThen :: LitNumType -> LitNumType -> [LitNumType]
$cenumFromTo :: LitNumType -> LitNumType -> [LitNumType]
enumFromTo :: LitNumType -> LitNumType -> [LitNumType]
$cenumFromThenTo :: LitNumType -> LitNumType -> LitNumType -> [LitNumType]
enumFromThenTo :: LitNumType -> LitNumType -> LitNumType -> [LitNumType]
Enum,LitNumType -> LitNumType -> Bool
(LitNumType -> LitNumType -> Bool)
-> (LitNumType -> LitNumType -> Bool) -> Eq LitNumType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LitNumType -> LitNumType -> Bool
== :: LitNumType -> LitNumType -> Bool
$c/= :: LitNumType -> LitNumType -> Bool
/= :: LitNumType -> LitNumType -> Bool
Eq,Eq LitNumType
Eq LitNumType =>
(LitNumType -> LitNumType -> Ordering)
-> (LitNumType -> LitNumType -> Bool)
-> (LitNumType -> LitNumType -> Bool)
-> (LitNumType -> LitNumType -> Bool)
-> (LitNumType -> LitNumType -> Bool)
-> (LitNumType -> LitNumType -> LitNumType)
-> (LitNumType -> LitNumType -> LitNumType)
-> Ord LitNumType
LitNumType -> LitNumType -> Bool
LitNumType -> LitNumType -> Ordering
LitNumType -> LitNumType -> LitNumType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: LitNumType -> LitNumType -> Ordering
compare :: LitNumType -> LitNumType -> Ordering
$c< :: LitNumType -> LitNumType -> Bool
< :: LitNumType -> LitNumType -> Bool
$c<= :: LitNumType -> LitNumType -> Bool
<= :: LitNumType -> LitNumType -> Bool
$c> :: LitNumType -> LitNumType -> Bool
> :: LitNumType -> LitNumType -> Bool
$c>= :: LitNumType -> LitNumType -> Bool
>= :: LitNumType -> LitNumType -> Bool
$cmax :: LitNumType -> LitNumType -> LitNumType
max :: LitNumType -> LitNumType -> LitNumType
$cmin :: LitNumType -> LitNumType -> LitNumType
min :: LitNumType -> LitNumType -> LitNumType
Ord)

-- | Indicate if a numeric literal type supports negative numbers
litNumIsSigned :: LitNumType -> Bool
litNumIsSigned :: LitNumType -> Bool
litNumIsSigned LitNumType
nt = case LitNumType
nt of
  LitNumType
LitNumBigNat  -> Bool
False
  LitNumType
LitNumInt     -> Bool
True
  LitNumType
LitNumInt8    -> Bool
True
  LitNumType
LitNumInt16   -> Bool
True
  LitNumType
LitNumInt32   -> Bool
True
  LitNumType
LitNumInt64   -> Bool
True
  LitNumType
LitNumWord    -> Bool
False
  LitNumType
LitNumWord8   -> Bool
False
  LitNumType
LitNumWord16  -> Bool
False
  LitNumType
LitNumWord32  -> Bool
False
  LitNumType
LitNumWord64  -> Bool
False

-- | Number of bits
litNumBitSize :: Platform -> LitNumType -> Maybe Word
litNumBitSize :: Platform -> LitNumType -> Maybe Word
litNumBitSize Platform
platform LitNumType
nt = case LitNumType
nt of
  LitNumType
LitNumBigNat  -> Maybe Word
forall a. Maybe a
Nothing
  LitNumType
LitNumInt     -> Word -> Maybe Word
forall a. a -> Maybe a
Just (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Platform -> Int
platformWordSizeInBits Platform
platform))
  LitNumType
LitNumInt8    -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
8
  LitNumType
LitNumInt16   -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
16
  LitNumType
LitNumInt32   -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
32
  LitNumType
LitNumInt64   -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
64
  LitNumType
LitNumWord    -> Word -> Maybe Word
forall a. a -> Maybe a
Just (Int -> Word
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Platform -> Int
platformWordSizeInBits Platform
platform))
  LitNumType
LitNumWord8   -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
8
  LitNumType
LitNumWord16  -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
16
  LitNumType
LitNumWord32  -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
32
  LitNumType
LitNumWord64  -> Word -> Maybe Word
forall a. a -> Maybe a
Just Word
64

instance Binary LitNumType where
   put_ :: BinHandle -> LitNumType -> IO ()
put_ BinHandle
bh LitNumType
numTyp = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (LitNumType -> Int
forall a. Enum a => a -> Int
fromEnum LitNumType
numTyp))
   get :: BinHandle -> IO LitNumType
get BinHandle
bh = do
      Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
      LitNumType -> IO LitNumType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> LitNumType
forall a. Enum a => Int -> a
toEnum (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
h))

{-
Note [BigNum literals]
~~~~~~~~~~~~~~~~~~~~~~
GHC supports 2 kinds of arbitrary precision numbers (a.k.a BigNum):

   * data Natural = NS Word# | NB BigNat#

   * data Integer = IS Int# | IN BigNat# | IP BigNat#

In the past, we had Core constructors to represent Integer and Natural literals.
These literals were then lowered into their real Core representation only in
Core prep. The issue with this approach is that literals have two
representations and we have to ensure that we handle them the same everywhere
(in every optimisation, etc.).

For example (0 :: Integer) was representable in Core with both:

    Lit (LitNumber LitNumInteger 0)                          -- literal
    App (Var integerISDataCon) (Lit (LitNumber LitNumInt 0)) -- real representation

Nowadays we always use the real representation for Integer and Natural literals.
However we still have two representations for BigNat# literals. BigNat# literals
are still lowered in Core prep into a call to a constructor function (BigNat# is
ByteArray# and we don't have ByteArray# literals yet so we have to build them at
runtime).

Note [String literals]
~~~~~~~~~~~~~~~~~~~~~~
String literals are UTF-8 encoded and stored into ByteStrings in the following
ASTs: Haskell, Core, Stg, Cmm. TH can also emit ByteString based string literals
with the BytesPrimL constructor (see #14741).

It wasn't true before as [Word8] was used in Cmm AST and in TH which was quite
bad for performance with large strings (see #16198 and #14741).

To include string literals into output objects, the assembler code generator has
to embed the UTF-8 encoded binary blob. See Note [Embedding large binary blobs]
for more details.

-}

instance Binary Literal where
    put_ :: BinHandle -> Literal -> IO ()
put_ BinHandle
bh (LitChar Char
aa)     = do BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
0; BinHandle -> Char -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Char
aa
    put_ BinHandle
bh (LitString ByteString
ab)   = do BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
1; BinHandle -> ByteString -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh ByteString
ab
    put_ BinHandle
bh (Literal
LitNullAddr)    = BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
2
    put_ BinHandle
bh (LitFloat Rational
ah)    = do BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
3; BinHandle -> Rational -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Rational
ah
    put_ BinHandle
bh (LitDouble Rational
ai)   = do BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
4; BinHandle -> Rational -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Rational
ai
    put_ BinHandle
bh (LitLabel FastString
aj Maybe Int
mb FunctionOrData
fod)
        = do BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
5
             BinHandle -> FastString -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh FastString
aj
             BinHandle -> Maybe Int -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Maybe Int
mb
             BinHandle -> FunctionOrData -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh FunctionOrData
fod
    put_ BinHandle
bh (LitNumber LitNumType
nt Integer
i)
        = do BinHandle -> Word8 -> IO ()
putByte BinHandle
bh Word8
6
             BinHandle -> LitNumType -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh LitNumType
nt
             BinHandle -> Integer -> IO ()
forall a. Binary a => BinHandle -> a -> IO ()
put_ BinHandle
bh Integer
i
    put_ BinHandle
_ lit :: Literal
lit@(LitRubbish {}) = String -> SDoc -> IO ()
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"Binary LitRubbish" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
lit)
     -- We use IfaceLitRubbish; see Note [Rubbish literals], item (6)

    get :: BinHandle -> IO Literal
get BinHandle
bh = do
            Word8
h <- BinHandle -> IO Word8
getByte BinHandle
bh
            case Word8
h of
              Word8
0 -> do
                    Char
aa <- BinHandle -> IO Char
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Literal -> IO Literal
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> Literal
LitChar Char
aa)
              Word8
1 -> do
                    ByteString
ab <- BinHandle -> IO ByteString
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Literal -> IO Literal
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString -> Literal
LitString ByteString
ab)
              Word8
2 -> Literal -> IO Literal
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Literal
LitNullAddr)
              Word8
3 -> do
                    Rational
ah <- BinHandle -> IO Rational
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Literal -> IO Literal
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Literal
LitFloat Rational
ah)
              Word8
4 -> do
                    Rational
ai <- BinHandle -> IO Rational
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Literal -> IO Literal
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Rational -> Literal
LitDouble Rational
ai)
              Word8
5 -> do
                    FastString
aj <- BinHandle -> IO FastString
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Maybe Int
mb <- BinHandle -> IO (Maybe Int)
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    FunctionOrData
fod <- BinHandle -> IO FunctionOrData
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Literal -> IO Literal
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (FastString -> Maybe Int -> FunctionOrData -> Literal
LitLabel FastString
aj Maybe Int
mb FunctionOrData
fod)
              Word8
6 -> do
                    LitNumType
nt <- BinHandle -> IO LitNumType
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Integer
i  <- BinHandle -> IO Integer
forall a. Binary a => BinHandle -> IO a
get BinHandle
bh
                    Literal -> IO Literal
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (LitNumType -> Integer -> Literal
LitNumber LitNumType
nt Integer
i)
              Word8
_ -> String -> SDoc -> IO Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"Binary:Literal" (Int -> SDoc
forall doc. IsLine doc => Int -> doc
int (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
h))


instance Outputable Literal where
    ppr :: Literal -> SDoc
ppr = (SDoc -> SDoc) -> Literal -> SDoc
pprLiteral SDoc -> SDoc
forall a. a -> a
id

instance Eq Literal where
    Literal
a == :: Literal -> Literal -> Bool
== Literal
b = Literal -> Literal -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Literal
a Literal
b Ordering -> Ordering -> Bool
forall a. Eq a => a -> a -> Bool
== Ordering
EQ

-- | Needed for the @Ord@ instance of 'AltCon', which in turn is needed in
-- 'GHC.Data.TrieMap.CoreMap'.
instance Ord Literal where
    compare :: Literal -> Literal -> Ordering
compare = Literal -> Literal -> Ordering
cmpLit

{-
        Construction
        ~~~~~~~~~~~~
-}

{- Note [Word/Int underflow/overflow]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
According to the Haskell Report 2010 (Sections 18.1 and 23.1 about signed and
unsigned integral types): "All arithmetic is performed modulo 2^n, where n is
the number of bits in the type."

GHC stores Word# and Int# constant values as Integer. Core optimizations such
as constant folding must ensure that the Integer value remains in the valid
target Word/Int range (see #13172). The following functions are used to
ensure this.

Note that we *don't* warn the user about overflow. It's not done at runtime
either, and compilation of completely harmless things like
   ((124076834 :: Word32) + (2147483647 :: Word32))
doesn't yield a warning. Instead we simply squash the value into the *target*
Int/Word range.
-}

-- | Make a literal number using wrapping semantics if the value is out of
-- bound.
mkLitNumberWrap :: Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap :: Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
nt Integer
i = case LitNumType
nt of
  LitNumType
LitNumInt -> case Platform -> PlatformWordSize
platformWordSize Platform
platform of
    PlatformWordSize
PW4 -> forall a. (Integral a, Num a) => Literal
wrap @Int32
    PlatformWordSize
PW8 -> forall a. (Integral a, Num a) => Literal
wrap @Int64
  LitNumType
LitNumWord -> case Platform -> PlatformWordSize
platformWordSize Platform
platform of
    PlatformWordSize
PW4 -> forall a. (Integral a, Num a) => Literal
wrap @Word32
    PlatformWordSize
PW8 -> forall a. (Integral a, Num a) => Literal
wrap @Word64
  LitNumType
LitNumInt8    -> forall a. (Integral a, Num a) => Literal
wrap @Int8
  LitNumType
LitNumInt16   -> forall a. (Integral a, Num a) => Literal
wrap @Int16
  LitNumType
LitNumInt32   -> forall a. (Integral a, Num a) => Literal
wrap @Int32
  LitNumType
LitNumInt64   -> forall a. (Integral a, Num a) => Literal
wrap @Int64
  LitNumType
LitNumWord8   -> forall a. (Integral a, Num a) => Literal
wrap @Word8
  LitNumType
LitNumWord16  -> forall a. (Integral a, Num a) => Literal
wrap @Word16
  LitNumType
LitNumWord32  -> forall a. (Integral a, Num a) => Literal
wrap @Word32
  LitNumType
LitNumWord64  -> forall a. (Integral a, Num a) => Literal
wrap @Word64
  LitNumType
LitNumBigNat
    | Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0     -> String -> Literal
forall a. HasCallStack => String -> a
panic String
"mkLitNumberWrap: trying to create a negative BigNat"
    | Bool
otherwise -> LitNumType -> Integer -> Literal
LitNumber LitNumType
nt Integer
i
  where
    wrap :: forall a. (Integral a, Num a) => Literal
    wrap :: forall a. (Integral a, Num a) => Literal
wrap = LitNumType -> Integer -> Literal
LitNumber LitNumType
nt (a -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: a))

-- | Wrap a literal number according to its type using wrapping semantics.
litNumWrap :: Platform -> Literal -> Literal
litNumWrap :: Platform -> Literal -> Literal
litNumWrap Platform
platform (LitNumber LitNumType
nt Integer
i) = Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
nt Integer
i
litNumWrap Platform
_        Literal
l                = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"litNumWrap" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

-- | Coerce a literal number into another using wrapping semantics.
litNumCoerce :: LitNumType -> Platform -> Literal -> Literal
litNumCoerce :: LitNumType -> Platform -> Literal -> Literal
litNumCoerce LitNumType
pt Platform
platform (LitNumber LitNumType
_nt Integer
i) = Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
pt Integer
i
litNumCoerce LitNumType
_  Platform
_        Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"litNumWrapCoerce: not a number" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

-- | Narrow a literal number by converting it into another number type and then
-- converting it back to its original type.
litNumNarrow :: LitNumType -> Platform -> Literal -> Literal
litNumNarrow :: LitNumType -> Platform -> Literal -> Literal
litNumNarrow LitNumType
pt Platform
platform (LitNumber LitNumType
nt Integer
i)
   = case Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
pt Integer
i of
      LitNumber LitNumType
_ Integer
j -> Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
nt Integer
j
      Literal
l             -> String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"litNumNarrow: got invalid literal" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)
litNumNarrow LitNumType
_ Platform
_ Literal
l = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"litNumNarrow: invalid literal" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)


-- | Check that a given number is in the range of a numeric literal
litNumCheckRange :: Platform -> LitNumType -> Integer -> Bool
litNumCheckRange :: Platform -> LitNumType -> Integer -> Bool
litNumCheckRange Platform
platform LitNumType
nt Integer
i =
    Bool -> (Integer -> Bool) -> Maybe Integer -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>=) Maybe Integer
m_lower Bool -> Bool -> Bool
&&
    Bool -> (Integer -> Bool) -> Maybe Integer -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True (Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<=) Maybe Integer
m_upper
  where
    (Maybe Integer
m_lower, Maybe Integer
m_upper) = Platform -> LitNumType -> (Maybe Integer, Maybe Integer)
litNumRange Platform
platform LitNumType
nt

-- | Get the literal range
litNumRange :: Platform -> LitNumType -> (Maybe Integer, Maybe Integer)
litNumRange :: Platform -> LitNumType -> (Maybe Integer, Maybe Integer)
litNumRange Platform
platform LitNumType
nt = case LitNumType
nt of
     LitNumType
LitNumInt     -> (Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Platform -> Integer
platformMinInt Platform
platform), Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Platform -> Integer
platformMaxInt Platform
platform))
     LitNumType
LitNumWord    -> (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0, Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Platform -> Integer
platformMaxWord Platform
platform))
     LitNumType
LitNumInt8    -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Int8
     LitNumType
LitNumInt16   -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Int16
     LitNumType
LitNumInt32   -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Int32
     LitNumType
LitNumInt64   -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Int64
     LitNumType
LitNumWord8   -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Word8
     LitNumType
LitNumWord16  -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Word16
     LitNumType
LitNumWord32  -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Word32
     LitNumType
LitNumWord64  -> forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range @Word64
     LitNumType
LitNumBigNat  -> (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
0, Maybe Integer
forall a. Maybe a
Nothing)
  where
    bounded_range :: forall a . (Integral a, Bounded a) => (Maybe Integer,Maybe Integer)
    bounded_range :: forall a. (Integral a, Bounded a) => (Maybe Integer, Maybe Integer)
bounded_range = case forall a. (Bounded a, Integral a) => (Integer, Integer)
boundedRange @a of
      (Integer
mi,Integer
ma) -> (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
mi, Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
ma)

-- | Create a numeric 'Literal' of the given type
mkLitNumber :: Platform -> LitNumType -> Integer -> Literal
mkLitNumber :: Platform -> LitNumType -> Integer -> Literal
mkLitNumber Platform
platform LitNumType
nt Integer
i =
  Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (Platform -> LitNumType -> Integer -> Bool
litNumCheckRange Platform
platform LitNumType
nt Integer
i) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
i)
  (LitNumType -> Integer -> Literal
LitNumber LitNumType
nt Integer
i)

-- | Creates a 'Literal' of type @Int#@
mkLitInt :: Platform -> Integer -> Literal
mkLitInt :: Platform -> Integer -> Literal
mkLitInt Platform
platform Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (Platform -> Integer -> Bool
platformInIntRange Platform
platform Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x)
                       (Integer -> Literal
mkLitIntUnchecked Integer
x)

-- | Creates a 'Literal' of type @Int#@.
--   If the argument is out of the (target-dependent) range, it is wrapped.
--   See Note [Word/Int underflow/overflow]
mkLitIntWrap :: Platform -> Integer -> Literal
mkLitIntWrap :: Platform -> Integer -> Literal
mkLitIntWrap Platform
platform Integer
i = Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
LitNumInt Integer
i

-- | Creates a 'Literal' of type @Int#@ without checking its range.
mkLitIntUnchecked :: Integer -> Literal
mkLitIntUnchecked :: Integer -> Literal
mkLitIntUnchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumInt Integer
i

-- | Creates a 'Literal' of type @Int#@, as well as a 'Bool'ean flag indicating
--   overflow. That is, if the argument is out of the (target-dependent) range
--   the argument is wrapped and the overflow flag will be set.
--   See Note [Word/Int underflow/overflow]
mkLitIntWrapC :: Platform -> Integer -> (Literal, Bool)
mkLitIntWrapC :: Platform -> Integer -> (Literal, Bool)
mkLitIntWrapC Platform
platform Integer
i = (Literal
n, Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
/= Integer
i')
  where
    n :: Literal
n@(LitNumber LitNumType
_ Integer
i') = Platform -> Integer -> Literal
mkLitIntWrap Platform
platform Integer
i

-- | Creates a 'Literal' of type @Word#@
mkLitWord :: Platform -> Integer -> Literal
mkLitWord :: Platform -> Integer -> Literal
mkLitWord Platform
platform Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (Platform -> Integer -> Bool
platformInWordRange Platform
platform Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x)
                        (Integer -> Literal
mkLitWordUnchecked Integer
x)

-- | Creates a 'Literal' of type @Word#@.
--   If the argument is out of the (target-dependent) range, it is wrapped.
--   See Note [Word/Int underflow/overflow]
mkLitWordWrap :: Platform -> Integer -> Literal
mkLitWordWrap :: Platform -> Integer -> Literal
mkLitWordWrap Platform
platform Integer
i = Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
LitNumWord Integer
i

-- | Creates a 'Literal' of type @Word#@ without checking its range.
mkLitWordUnchecked :: Integer -> Literal
mkLitWordUnchecked :: Integer -> Literal
mkLitWordUnchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumWord Integer
i

-- | Creates a 'Literal' of type @Word#@, as well as a 'Bool'ean flag indicating
--   carry. That is, if the argument is out of the (target-dependent) range
--   the argument is wrapped and the carry flag will be set.
--   See Note [Word/Int underflow/overflow]
mkLitWordWrapC :: Platform -> Integer -> (Literal, Bool)
mkLitWordWrapC :: Platform -> Integer -> (Literal, Bool)
mkLitWordWrapC Platform
platform Integer
i = (Literal
n, Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
/= Integer
i')
  where
    n :: Literal
n@(LitNumber LitNumType
_ Integer
i') = Platform -> Integer -> Literal
mkLitWordWrap Platform
platform Integer
i

-- | Creates a 'Literal' of type @Int8#@
mkLitInt8 :: Integer -> Literal
mkLitInt8 :: Integer -> Literal
mkLitInt8  Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Int8 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitInt8Unchecked Integer
x)

-- | Creates a 'Literal' of type @Int8#@.
--   If the argument is out of the range, it is wrapped.
mkLitInt8Wrap :: Integer -> Literal
mkLitInt8Wrap :: Integer -> Literal
mkLitInt8Wrap Integer
i = Integer -> Literal
mkLitInt8Unchecked (Int8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Int8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Int8))

-- | Creates a 'Literal' of type @Int8#@ without checking its range.
mkLitInt8Unchecked :: Integer -> Literal
mkLitInt8Unchecked :: Integer -> Literal
mkLitInt8Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumInt8 Integer
i

-- | Creates a 'Literal' of type @Word8#@
mkLitWord8 :: Integer -> Literal
mkLitWord8 :: Integer -> Literal
mkLitWord8 Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Word8 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitWord8Unchecked Integer
x)

-- | Creates a 'Literal' of type @Word8#@.
--   If the argument is out of the range, it is wrapped.
mkLitWord8Wrap :: Integer -> Literal
mkLitWord8Wrap :: Integer -> Literal
mkLitWord8Wrap Integer
i = Integer -> Literal
mkLitWord8Unchecked (Word8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Word8))

-- | Creates a 'Literal' of type @Word8#@ without checking its range.
mkLitWord8Unchecked :: Integer -> Literal
mkLitWord8Unchecked :: Integer -> Literal
mkLitWord8Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumWord8 Integer
i

-- | Creates a 'Literal' of type @Int16#@
mkLitInt16 :: Integer -> Literal
mkLitInt16 :: Integer -> Literal
mkLitInt16  Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Int16 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitInt16Unchecked Integer
x)

-- | Creates a 'Literal' of type @Int16#@.
--   If the argument is out of the range, it is wrapped.
mkLitInt16Wrap :: Integer -> Literal
mkLitInt16Wrap :: Integer -> Literal
mkLitInt16Wrap Integer
i = Integer -> Literal
mkLitInt16Unchecked (Int16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Int16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Int16))

-- | Creates a 'Literal' of type @Int16#@ without checking its range.
mkLitInt16Unchecked :: Integer -> Literal
mkLitInt16Unchecked :: Integer -> Literal
mkLitInt16Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumInt16 Integer
i

-- | Creates a 'Literal' of type @Word16#@
mkLitWord16 :: Integer -> Literal
mkLitWord16 :: Integer -> Literal
mkLitWord16 Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Word16 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitWord16Unchecked Integer
x)

-- | Creates a 'Literal' of type @Word16#@.
--   If the argument is out of the range, it is wrapped.
mkLitWord16Wrap :: Integer -> Literal
mkLitWord16Wrap :: Integer -> Literal
mkLitWord16Wrap Integer
i = Integer -> Literal
mkLitWord16Unchecked (Word16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Word16
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Word16))

-- | Creates a 'Literal' of type @Word16#@ without checking its range.
mkLitWord16Unchecked :: Integer -> Literal
mkLitWord16Unchecked :: Integer -> Literal
mkLitWord16Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumWord16 Integer
i

-- | Creates a 'Literal' of type @Int32#@
mkLitInt32 :: Integer -> Literal
mkLitInt32 :: Integer -> Literal
mkLitInt32  Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Int32 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitInt32Unchecked Integer
x)

-- | Creates a 'Literal' of type @Int32#@.
--   If the argument is out of the range, it is wrapped.
mkLitInt32Wrap :: Integer -> Literal
mkLitInt32Wrap :: Integer -> Literal
mkLitInt32Wrap Integer
i = Integer -> Literal
mkLitInt32Unchecked (Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Int32))

-- | Creates a 'Literal' of type @Int32#@ without checking its range.
mkLitInt32Unchecked :: Integer -> Literal
mkLitInt32Unchecked :: Integer -> Literal
mkLitInt32Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumInt32 Integer
i

-- | Creates a 'Literal' of type @Word32#@
mkLitWord32 :: Integer -> Literal
mkLitWord32 :: Integer -> Literal
mkLitWord32 Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Word32 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitWord32Unchecked Integer
x)

-- | Creates a 'Literal' of type @Word32#@.
--   If the argument is out of the range, it is wrapped.
mkLitWord32Wrap :: Integer -> Literal
mkLitWord32Wrap :: Integer -> Literal
mkLitWord32Wrap Integer
i = Integer -> Literal
mkLitWord32Unchecked (Word32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Word32
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Word32))

-- | Creates a 'Literal' of type @Word32#@ without checking its range.
mkLitWord32Unchecked :: Integer -> Literal
mkLitWord32Unchecked :: Integer -> Literal
mkLitWord32Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumWord32 Integer
i

-- | Creates a 'Literal' of type @Int64#@
mkLitInt64 :: Integer -> Literal
mkLitInt64 :: Integer -> Literal
mkLitInt64  Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Int64 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitInt64Unchecked Integer
x)

-- | Creates a 'Literal' of type @Int64#@.
--   If the argument is out of the range, it is wrapped.
mkLitInt64Wrap :: Integer -> Literal
mkLitInt64Wrap :: Integer -> Literal
mkLitInt64Wrap Integer
i = Integer -> Literal
mkLitInt64Unchecked (Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Int64))

-- | Creates a 'Literal' of type @Int64#@ without checking its range.
mkLitInt64Unchecked :: Integer -> Literal
mkLitInt64Unchecked :: Integer -> Literal
mkLitInt64Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumInt64 Integer
i

-- | Creates a 'Literal' of type @Word64#@
mkLitWord64 :: Integer -> Literal
mkLitWord64 :: Integer -> Literal
mkLitWord64 Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange @Word64 Integer
x) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x) (Integer -> Literal
mkLitWord64Unchecked Integer
x)

-- | Creates a 'Literal' of type @Word64#@.
--   If the argument is out of the range, it is wrapped.
mkLitWord64Wrap :: Integer -> Literal
mkLitWord64Wrap :: Integer -> Literal
mkLitWord64Wrap Integer
i = Integer -> Literal
mkLitWord64Unchecked (Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i :: Word64))

-- | Creates a 'Literal' of type @Word64#@ without checking its range.
mkLitWord64Unchecked :: Integer -> Literal
mkLitWord64Unchecked :: Integer -> Literal
mkLitWord64Unchecked Integer
i = LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumWord64 Integer
i

-- | Creates a 'Literal' of type @Float#@
mkLitFloat :: Rational -> Literal
mkLitFloat :: Rational -> Literal
mkLitFloat = Rational -> Literal
LitFloat

-- | Creates a 'Literal' of type @Double#@
mkLitDouble :: Rational -> Literal
mkLitDouble :: Rational -> Literal
mkLitDouble = Rational -> Literal
LitDouble

-- | Creates a 'Literal' of type @Char#@
mkLitChar :: Char -> Literal
mkLitChar :: Char -> Literal
mkLitChar = Char -> Literal
LitChar

-- | Creates a 'Literal' of type @Addr#@, which is appropriate for passing to
-- e.g. some of the \"error\" functions in GHC.Err such as @GHC.Err.runtimeError@
mkLitString :: String -> Literal
-- stored UTF-8 encoded
mkLitString :: String -> Literal
mkLitString [] = ByteString -> Literal
LitString ByteString
forall a. Monoid a => a
mempty
mkLitString String
s  = ByteString -> Literal
LitString (String -> ByteString
utf8EncodeByteString String
s)

mkLitBigNat :: Integer -> Literal
mkLitBigNat :: Integer -> Literal
mkLitBigNat Integer
x = Bool -> SDoc -> Literal -> Literal
forall a. HasCallStack => Bool -> SDoc -> a -> a
assertPpr (Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
0) (Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
x)
                    (LitNumType -> Integer -> Literal
LitNumber LitNumType
LitNumBigNat Integer
x)

isLitRubbish :: Literal -> Bool
isLitRubbish :: Literal -> Bool
isLitRubbish (LitRubbish {}) = Bool
True
isLitRubbish Literal
_               = Bool
False

inBoundedRange :: forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange :: forall a. (Bounded a, Integral a) => Integer -> Bool
inBoundedRange Integer
x  = Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= a -> Integer
forall a. Integral a => a -> Integer
toInteger (a
forall a. Bounded a => a
minBound :: a) Bool -> Bool -> Bool
&&
                    Integer
x Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= a -> Integer
forall a. Integral a => a -> Integer
toInteger (a
forall a. Bounded a => a
maxBound :: a)

boundedRange :: forall a. (Bounded a, Integral a) => (Integer,Integer)
boundedRange :: forall a. (Bounded a, Integral a) => (Integer, Integer)
boundedRange = (a -> Integer
forall a. Integral a => a -> Integer
toInteger (a
forall a. Bounded a => a
minBound :: a), a -> Integer
forall a. Integral a => a -> Integer
toInteger (a
forall a. Bounded a => a
maxBound :: a))

isMinBound :: Platform -> Literal -> Bool
isMinBound :: Platform -> Literal -> Bool
isMinBound Platform
_        (LitChar Char
c)        = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
forall a. Bounded a => a
minBound
isMinBound Platform
platform (LitNumber LitNumType
nt Integer
i)   = case LitNumType
nt of
   LitNumType
LitNumInt     -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Platform -> Integer
platformMinInt Platform
platform
   LitNumType
LitNumInt8    -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int8
forall a. Bounded a => a
minBound :: Int8)
   LitNumType
LitNumInt16   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int16
forall a. Bounded a => a
minBound :: Int16)
   LitNumType
LitNumInt32   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int32
forall a. Bounded a => a
minBound :: Int32)
   LitNumType
LitNumInt64   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int64
forall a. Bounded a => a
minBound :: Int64)
   LitNumType
LitNumWord    -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
   LitNumType
LitNumWord8   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
   LitNumType
LitNumWord16  -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
   LitNumType
LitNumWord32  -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
   LitNumType
LitNumWord64  -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
   LitNumType
LitNumBigNat  -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Integer
0
isMinBound Platform
_        Literal
_                  = Bool
False

isMaxBound :: Platform -> Literal -> Bool
isMaxBound :: Platform -> Literal -> Bool
isMaxBound Platform
_        (LitChar Char
c)        = Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
forall a. Bounded a => a
maxBound
isMaxBound Platform
platform (LitNumber LitNumType
nt Integer
i)   = case LitNumType
nt of
   LitNumType
LitNumInt     -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Platform -> Integer
platformMaxInt Platform
platform
   LitNumType
LitNumInt8    -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int8
forall a. Bounded a => a
maxBound :: Int8)
   LitNumType
LitNumInt16   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int16
forall a. Bounded a => a
maxBound :: Int16)
   LitNumType
LitNumInt32   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int32
forall a. Bounded a => a
maxBound :: Int32)
   LitNumType
LitNumInt64   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Int64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Int64
forall a. Bounded a => a
maxBound :: Int64)
   LitNumType
LitNumWord    -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Platform -> Integer
platformMaxWord Platform
platform
   LitNumType
LitNumWord8   -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Word8 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word8
forall a. Bounded a => a
maxBound :: Word8)
   LitNumType
LitNumWord16  -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Word16 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word16
forall a. Bounded a => a
maxBound :: Word16)
   LitNumType
LitNumWord32  -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Word32 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word32
forall a. Bounded a => a
maxBound :: Word32)
   LitNumType
LitNumWord64  -> Integer
i Integer -> Integer -> Bool
forall a. Eq a => a -> a -> Bool
== Word64 -> Integer
forall a. Integral a => a -> Integer
toInteger (Word64
forall a. Bounded a => a
maxBound :: Word64)
   LitNumType
LitNumBigNat  -> Bool
False
isMaxBound Platform
_        Literal
_                  = Bool
False

inCharRange :: Char -> Bool
inCharRange :: Char -> Bool
inCharRange Char
c =  Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
'\0' Bool -> Bool -> Bool
&& Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
<= Int -> Char
chr Int
tARGET_MAX_CHAR

-- | Tests whether the literal represents a zero of whatever type it is
isZeroLit :: Literal -> Bool
isZeroLit :: Literal -> Bool
isZeroLit (LitNumber LitNumType
_ Integer
0) = Bool
True
isZeroLit (LitFloat  Rational
0)   = Bool
True
isZeroLit (LitDouble Rational
0)   = Bool
True
isZeroLit Literal
_               = Bool
False

-- | Tests whether the literal represents a one of whatever type it is
isOneLit :: Literal -> Bool
isOneLit :: Literal -> Bool
isOneLit (LitNumber LitNumType
_ Integer
1) = Bool
True
isOneLit (LitFloat  Rational
1)   = Bool
True
isOneLit (LitDouble Rational
1)   = Bool
True
isOneLit Literal
_               = Bool
False

-- | Returns the 'Integer' contained in the 'Literal', for when that makes
-- sense, i.e. for 'Char' and numbers.
litValue  :: Literal -> Integer
litValue :: Literal -> Integer
litValue Literal
l = case Literal -> Maybe Integer
isLitValue_maybe Literal
l of
   Just Integer
x  -> Integer
x
   Maybe Integer
Nothing -> String -> SDoc -> Integer
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"litValue" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

-- | Returns the 'Integer' contained in the 'Literal', for when that makes
-- sense, i.e. for 'Char' and numbers.
isLitValue_maybe  :: Literal -> Maybe Integer
isLitValue_maybe :: Literal -> Maybe Integer
isLitValue_maybe (LitChar   Char
c)     = Integer -> Maybe Integer
forall a. a -> Maybe a
Just (Integer -> Maybe Integer) -> Integer -> Maybe Integer
forall a b. (a -> b) -> a -> b
$ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ Char -> Int
ord Char
c
isLitValue_maybe (LitNumber LitNumType
_ Integer
i)   = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
i
isLitValue_maybe Literal
_                 = Maybe Integer
forall a. Maybe a
Nothing

-- | Apply a function to the 'Integer' contained in the 'Literal', for when that
-- makes sense, e.g. for 'Char' and numbers.
-- For fixed-size integral literals, the result will be wrapped in accordance
-- with the semantics of the target type.
-- See Note [Word/Int underflow/overflow]
mapLitValue  :: Platform -> (Integer -> Integer) -> Literal -> Literal
mapLitValue :: Platform -> (Integer -> Integer) -> Literal -> Literal
mapLitValue Platform
_        Integer -> Integer
f (LitChar   Char
c)      = Char -> Literal
mkLitChar (Char -> Char
fchar Char
c)
   where fchar :: Char -> Char
fchar = Int -> Char
chr (Int -> Char) -> (Char -> Int) -> Char -> Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Int
forall a. Num a => Integer -> a
fromInteger (Integer -> Int) -> (Char -> Integer) -> Char -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Integer
f (Integer -> Integer) -> (Char -> Integer) -> Char -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Integer) -> (Char -> Int) -> Char -> Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord
mapLitValue Platform
platform Integer -> Integer
f (LitNumber LitNumType
nt Integer
i)   = Platform -> LitNumType -> Integer -> Literal
mkLitNumberWrap Platform
platform LitNumType
nt (Integer -> Integer
f Integer
i)
mapLitValue Platform
_        Integer -> Integer
_ Literal
l                  = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"mapLitValue" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

{-
        Coercions
        ~~~~~~~~~
-}

charToIntLit, intToCharLit,
  floatToIntLit, intToFloatLit,
  doubleToIntLit, intToDoubleLit,
  floatToDoubleLit, doubleToFloatLit
  :: Literal -> Literal

-- | Narrow a literal number (unchecked result range)
narrowLit' :: forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' :: forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' LitNumType
nt' (LitNumber LitNumType
_ Integer
i)  = LitNumType -> Integer -> Literal
LitNumber LitNumType
nt' (a -> Integer
forall a. Integral a => a -> Integer
toInteger (Integer -> a
forall a. Num a => Integer -> a
fromInteger Integer
i :: a))
narrowLit' LitNumType
_   Literal
l                = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"narrowLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

narrowInt8Lit, narrowInt16Lit, narrowInt32Lit, narrowInt64Lit,
  narrowWord8Lit, narrowWord16Lit, narrowWord32Lit, narrowWord64Lit :: Literal -> Literal
narrowInt8Lit :: Literal -> Literal
narrowInt8Lit   = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Int8   LitNumType
LitNumInt8
narrowInt16Lit :: Literal -> Literal
narrowInt16Lit  = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Int16  LitNumType
LitNumInt16
narrowInt32Lit :: Literal -> Literal
narrowInt32Lit  = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Int32  LitNumType
LitNumInt32
narrowInt64Lit :: Literal -> Literal
narrowInt64Lit  = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Int64  LitNumType
LitNumInt64
narrowWord8Lit :: Literal -> Literal
narrowWord8Lit  = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Word8  LitNumType
LitNumWord8
narrowWord16Lit :: Literal -> Literal
narrowWord16Lit = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Word16 LitNumType
LitNumWord16
narrowWord32Lit :: Literal -> Literal
narrowWord32Lit = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Word32 LitNumType
LitNumWord32
narrowWord64Lit :: Literal -> Literal
narrowWord64Lit = forall a. Integral a => LitNumType -> Literal -> Literal
narrowLit' @Word64 LitNumType
LitNumWord64

-- | Extend or narrow a fixed-width literal (e.g. 'Int16#') to a target
-- word-sized literal ('Int#' or 'Word#'). Narrowing can only happen on 32-bit
-- architectures when we convert a 64-bit literal into a 32-bit one.
convertToWordLit, convertToIntLit :: Platform -> Literal -> Literal
convertToWordLit :: Platform -> Literal -> Literal
convertToWordLit Platform
platform (LitNumber LitNumType
_nt Integer
i)  = Platform -> Integer -> Literal
mkLitWordWrap Platform
platform Integer
i
convertToWordLit Platform
_platform Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"convertToWordLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)
convertToIntLit :: Platform -> Literal -> Literal
convertToIntLit  Platform
platform (LitNumber LitNumType
_nt Integer
i)  = Platform -> Integer -> Literal
mkLitIntWrap Platform
platform Integer
i
convertToIntLit  Platform
_platform Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"convertToIntLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

charToIntLit :: Literal -> Literal
charToIntLit (LitChar Char
c)       = Integer -> Literal
mkLitIntUnchecked (Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Char -> Int
ord Char
c))
charToIntLit Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"charToIntLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)
intToCharLit :: Literal -> Literal
intToCharLit (LitNumber LitNumType
_ Integer
i)   = Char -> Literal
LitChar (Int -> Char
chr (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
i))
intToCharLit Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"intToCharLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

floatToIntLit :: Literal -> Literal
floatToIntLit (LitFloat Rational
f)      = Integer -> Literal
mkLitIntUnchecked (Rational -> Integer
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate Rational
f)
floatToIntLit Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"floatToIntLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)
intToFloatLit :: Literal -> Literal
intToFloatLit (LitNumber LitNumType
_ Integer
i)   = Rational -> Literal
LitFloat (Integer -> Rational
forall a. Num a => Integer -> a
fromInteger Integer
i)
intToFloatLit Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"intToFloatLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

doubleToIntLit :: Literal -> Literal
doubleToIntLit (LitDouble Rational
f)     = Integer -> Literal
mkLitIntUnchecked (Rational -> Integer
forall b. Integral b => Rational -> b
forall a b. (RealFrac a, Integral b) => a -> b
truncate Rational
f)
doubleToIntLit Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"doubleToIntLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)
intToDoubleLit :: Literal -> Literal
intToDoubleLit (LitNumber LitNumType
_ Integer
i)   = Rational -> Literal
LitDouble (Integer -> Rational
forall a. Num a => Integer -> a
fromInteger Integer
i)
intToDoubleLit Literal
l                 = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"intToDoubleLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

floatToDoubleLit :: Literal -> Literal
floatToDoubleLit (LitFloat  Rational
f) = Rational -> Literal
LitDouble Rational
f
floatToDoubleLit Literal
l             = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"floatToDoubleLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)
doubleToFloatLit :: Literal -> Literal
doubleToFloatLit (LitDouble Rational
d) = Rational -> Literal
LitFloat  Rational
d
doubleToFloatLit Literal
l             = String -> SDoc -> Literal
forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"doubleToFloatLit" (Literal -> SDoc
forall a. Outputable a => a -> SDoc
ppr Literal
l)

nullAddrLit :: Literal
nullAddrLit :: Literal
nullAddrLit = Literal
LitNullAddr

{-
        Predicates
        ~~~~~~~~~~
-}

-- | True if there is absolutely no penalty to duplicating the literal.
-- False principally of strings.
--
-- "Why?", you say? I'm glad you asked. Well, for one duplicating strings would
-- blow up code sizes. Not only this, it's also unsafe.
--
-- Consider a program that wants to traverse a string. One way it might do this
-- is to first compute the Addr# pointing to the end of the string, and then,
-- starting from the beginning, bump a pointer using eqAddr# to determine the
-- end. For instance,
--
-- @
-- -- Given pointers to the start and end of a string, count how many zeros
-- -- the string contains.
-- countZeros :: Addr# -> Addr# -> -> Int
-- countZeros start end = go start 0
--   where
--     go off n
--       | off `addrEq#` end = n
--       | otherwise         = go (off `plusAddr#` 1) n'
--       where n' | isTrue# (indexInt8OffAddr# off 0# ==# 0#) = n + 1
--                | otherwise                                 = n
-- @
--
-- Consider what happens if we considered strings to be trivial (and therefore
-- duplicable) and emitted a call like @countZeros "hello"# ("hello"#
-- `plusAddr`# 5)@. The beginning and end pointers do not belong to the same
-- string, meaning that an iteration like the above would blow up terribly.
-- This is what happened in #12757.
--
-- Ultimately the solution here is to make primitive strings a bit more
-- structured, ensuring that the compiler can't inline in ways that will break
-- user code. One approach to this is described in #8472.
litIsTrivial :: Literal -> Bool
--      c.f. GHC.Core.Utils.exprIsTrivial
litIsTrivial :: Literal -> Bool
litIsTrivial (LitString ByteString
_)    = Bool
False
litIsTrivial (LitNumber LitNumType
nt Integer
_) = case LitNumType
nt of
  LitNumType
LitNumBigNat  -> Bool
False
  LitNumType
LitNumInt     -> Bool
True
  LitNumType
LitNumInt8    -> Bool
True
  LitNumType
LitNumInt16   -> Bool
True
  LitNumType
LitNumInt32   -> Bool
True
  LitNumType
LitNumInt64   -> Bool
True
  LitNumType
LitNumWord    -> Bool
True
  LitNumType
LitNumWord8   -> Bool
True
  LitNumType
LitNumWord16  -> Bool
True
  LitNumType
LitNumWord32  -> Bool
True
  LitNumType
LitNumWord64  -> Bool
True
litIsTrivial Literal
_                  = Bool
True

-- | True if code space does not go bad if we duplicate this literal
litIsDupable :: Platform -> Literal -> Bool
--      c.f. GHC.Core.Utils.exprIsDupable
litIsDupable :: Platform -> Literal -> Bool
litIsDupable Platform
platform Literal
x = case Literal
x of
   LitNumber LitNumType
nt Integer
i -> case LitNumType
nt of
      LitNumType
LitNumBigNat  -> Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Platform -> Integer
platformMaxWord Platform
platform Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
* Integer
8 -- arbitrary, reasonable
      LitNumType
LitNumInt     -> Bool
True
      LitNumType
LitNumInt8    -> Bool
True
      LitNumType
LitNumInt16   -> Bool
True
      LitNumType
LitNumInt32   -> Bool
True
      LitNumType
LitNumInt64   -> Bool
True
      LitNumType
LitNumWord    -> Bool
True
      LitNumType
LitNumWord8   -> Bool
True
      LitNumType
LitNumWord16  -> Bool
True
      LitNumType
LitNumWord32  -> Bool
True
      LitNumType
LitNumWord64  -> Bool
True
   LitString ByteString
_ -> Bool
False
   Literal
_           -> Bool
True

litFitsInChar :: Literal -> Bool
litFitsInChar :: Literal -> Bool
litFitsInChar (LitNumber LitNumType
_ Integer
i) = Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Char -> Int
ord Char
forall a. Bounded a => a
minBound)
                              Bool -> Bool -> Bool
&& Integer
i Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
<= Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Char -> Int
ord Char
forall a. Bounded a => a
maxBound)
litFitsInChar Literal
_               = Bool
False

litIsLifted :: Literal -> Bool
litIsLifted :: Literal -> Bool
litIsLifted (LitNumber LitNumType
nt Integer
_) = case LitNumType
nt of
  LitNumType
LitNumBigNat  -> Bool
True
  LitNumType
LitNumInt     -> Bool
False
  LitNumType
LitNumInt8    -> Bool
False
  LitNumType
LitNumInt16   -> Bool
False
  LitNumType
LitNumInt32   -> Bool
False
  LitNumType
LitNumInt64   -> Bool
False
  LitNumType
LitNumWord    -> Bool
False
  LitNumType
LitNumWord8   -> Bool
False
  LitNumType
LitNumWord16  -> Bool
False
  LitNumType
LitNumWord32  -> Bool
False
  LitNumType
LitNumWord64  -> Bool
False
litIsLifted Literal
_                        = Bool
False
  -- Even RUBBISH[LiftedRep] is unlifted, as rubbish values are always evaluated.

{-
        Types
        ~~~~~
-}

-- | Find the Haskell 'Type' the literal occupies
literalType :: Literal -> Type
literalType :: Literal -> RuntimeRepType
literalType Literal
LitNullAddr       = RuntimeRepType
addrPrimTy
literalType (LitChar Char
_)       = RuntimeRepType
charPrimTy
literalType (LitString  ByteString
_)    = RuntimeRepType
addrPrimTy
literalType (LitFloat Rational
_)      = RuntimeRepType
floatPrimTy
literalType (LitDouble Rational
_)     = RuntimeRepType
doublePrimTy
literalType (LitLabel FastString
_ Maybe Int
_ FunctionOrData
_)  = RuntimeRepType
addrPrimTy
literalType (LitNumber LitNumType
lt Integer
_)  = case LitNumType
lt of
   LitNumType
LitNumBigNat  -> RuntimeRepType
byteArrayPrimTy
   LitNumType
LitNumInt     -> RuntimeRepType
intPrimTy
   LitNumType
LitNumInt8    -> RuntimeRepType
int8PrimTy
   LitNumType
LitNumInt16   -> RuntimeRepType
int16PrimTy
   LitNumType
LitNumInt32   -> RuntimeRepType
int32PrimTy
   LitNumType
LitNumInt64   -> RuntimeRepType
int64PrimTy
   LitNumType
LitNumWord    -> RuntimeRepType
wordPrimTy
   LitNumType
LitNumWord8   -> RuntimeRepType
word8PrimTy
   LitNumType
LitNumWord16  -> RuntimeRepType
word16PrimTy
   LitNumType
LitNumWord32  -> RuntimeRepType
word32PrimTy
   LitNumType
LitNumWord64  -> RuntimeRepType
word64PrimTy

-- LitRubbish: see Note [Rubbish literals]
literalType (LitRubbish TypeOrConstraint
torc RuntimeRepType
rep)
  = ForAllTyBinder -> RuntimeRepType -> RuntimeRepType
mkForAllTy (TyCoVar -> ForAllTyFlag -> ForAllTyBinder
forall var argf. var -> argf -> VarBndr var argf
Bndr TyCoVar
a ForAllTyFlag
Inferred) (TyCoVar -> RuntimeRepType
mkTyVarTy TyCoVar
a)
  where
    a :: TyCoVar
a = RuntimeRepType -> TyCoVar
mkTemplateKindVar (TypeOrConstraint -> RuntimeRepType -> RuntimeRepType
typeOrConstraintKind TypeOrConstraint
torc RuntimeRepType
rep)

{-
        Comparison
        ~~~~~~~~~~
-}

cmpLit :: Literal -> Literal -> Ordering
cmpLit :: Literal -> Literal -> Ordering
cmpLit (LitChar      Char
a)     (LitChar       Char
b)     = Char
a Char -> Char -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Char
b
cmpLit (LitString    ByteString
a)     (LitString     ByteString
b)     = ByteString
a ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` ByteString
b
cmpLit (Literal
LitNullAddr)        (Literal
LitNullAddr)         = Ordering
EQ
cmpLit (LitFloat     Rational
a)     (LitFloat      Rational
b)     = Rational
a Rational -> Rational -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Rational
b
cmpLit (LitDouble    Rational
a)     (LitDouble     Rational
b)     = Rational
a Rational -> Rational -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Rational
b
cmpLit (LitLabel     FastString
a Maybe Int
_ FunctionOrData
_) (LitLabel      FastString
b Maybe Int
_ FunctionOrData
_) = FastString
a FastString -> FastString -> Ordering
`lexicalCompareFS` FastString
b
cmpLit (LitNumber LitNumType
nt1 Integer
a)    (LitNumber LitNumType
nt2  Integer
b)
  = (LitNumType
nt1 LitNumType -> LitNumType -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` LitNumType
nt2) Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend` (Integer
a Integer -> Integer -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` Integer
b)
cmpLit (LitRubbish TypeOrConstraint
tc1 RuntimeRepType
b1)  (LitRubbish TypeOrConstraint
tc2 RuntimeRepType
b2)  = (TypeOrConstraint
tc1 TypeOrConstraint -> TypeOrConstraint -> Ordering
forall a. Ord a => a -> a -> Ordering
`compare` TypeOrConstraint
tc2) Ordering -> Ordering -> Ordering
forall a. Monoid a => a -> a -> a
`mappend`
                                                   (RuntimeRepType
b1 RuntimeRepType -> RuntimeRepType -> Ordering
`nonDetCmpType` RuntimeRepType
b2)
cmpLit Literal
lit1 Literal
lit2
  | Int# -> Bool
isTrue# (Literal -> Int#
forall a. a -> Int#
dataToTag# Literal
lit1 Int# -> Int# -> Int#
<# Literal -> Int#
forall a. a -> Int#
dataToTag# Literal
lit2) = Ordering
LT
  | Bool
otherwise                                    = Ordering
GT

{-
        Printing
        ~~~~~~~~
* See Note [Printing of literals in Core]
-}

pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc
pprLiteral :: (SDoc -> SDoc) -> Literal -> SDoc
pprLiteral SDoc -> SDoc
_       (LitChar Char
c)     = Char -> SDoc
pprPrimChar Char
c
pprLiteral SDoc -> SDoc
_       (LitString ByteString
s)   = ByteString -> SDoc
pprHsBytes ByteString
s
pprLiteral SDoc -> SDoc
_       (Literal
LitNullAddr)   = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"__NULL"
pprLiteral SDoc -> SDoc
_       (LitFloat Rational
f)    = Float -> SDoc
forall doc. IsLine doc => Float -> doc
float (Rational -> Float
forall a. RealFloat a => Rational -> a
fromRat Rational
f) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc
primFloatSuffix
pprLiteral SDoc -> SDoc
_       (LitDouble Rational
d)   = Double -> SDoc
forall doc. IsLine doc => Double -> doc
double (Rational -> Double
forall a. RealFloat a => Rational -> a
fromRat Rational
d) SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc
primDoubleSuffix
pprLiteral SDoc -> SDoc
_       (LitNumber LitNumType
nt Integer
i)
   = case LitNumType
nt of
       LitNumType
LitNumBigNat  -> Integer -> SDoc
forall doc. IsLine doc => Integer -> doc
integer Integer
i
       LitNumType
LitNumInt     -> Integer -> SDoc
pprPrimInt Integer
i
       LitNumType
LitNumInt8    -> Integer -> SDoc
pprPrimInt8 Integer
i
       LitNumType
LitNumInt16   -> Integer -> SDoc
pprPrimInt16 Integer
i
       LitNumType
LitNumInt32   -> Integer -> SDoc
pprPrimInt32 Integer
i
       LitNumType
LitNumInt64   -> Integer -> SDoc
pprPrimInt64 Integer
i
       LitNumType
LitNumWord    -> Integer -> SDoc
pprPrimWord Integer
i
       LitNumType
LitNumWord8   -> Integer -> SDoc
pprPrimWord8 Integer
i
       LitNumType
LitNumWord16  -> Integer -> SDoc
pprPrimWord16 Integer
i
       LitNumType
LitNumWord32  -> Integer -> SDoc
pprPrimWord32 Integer
i
       LitNumType
LitNumWord64  -> Integer -> SDoc
pprPrimWord64 Integer
i
pprLiteral SDoc -> SDoc
add_par (LitLabel FastString
l Maybe Int
mb FunctionOrData
fod) =
    SDoc -> SDoc
add_par (String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"__label" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> SDoc
b SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<+> FunctionOrData -> SDoc
forall a. Outputable a => a -> SDoc
ppr FunctionOrData
fod)
    where b :: SDoc
b = case Maybe Int
mb of
              Maybe Int
Nothing -> FastString -> SDoc
pprHsString FastString
l
              Just Int
x  -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
doubleQuotes (FastString -> SDoc
forall doc. IsLine doc => FastString -> doc
ftext FastString
l SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> String -> SDoc
forall doc. IsLine doc => String -> doc
text (Char
'@'Char -> String -> String
forall a. a -> [a] -> [a]
:Int -> String
forall a. Show a => a -> String
show Int
x))
pprLiteral SDoc -> SDoc
_       (LitRubbish TypeOrConstraint
torc RuntimeRepType
rep)
  = String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"RUBBISH" SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc
pp_tc SDoc -> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc -> doc
<> SDoc -> SDoc
forall doc. IsLine doc => doc -> doc
parens (RuntimeRepType -> SDoc
forall a. Outputable a => a -> SDoc
ppr RuntimeRepType
rep)
  where
  pp_tc :: SDoc
pp_tc = case TypeOrConstraint
torc of
           TypeOrConstraint
TypeLike       -> SDoc
forall doc. IsOutput doc => doc
empty
           TypeOrConstraint
ConstraintLike -> String -> SDoc
forall doc. IsLine doc => String -> doc
text String
"[c]"

{-
Note [Printing of literals in Core]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The function `add_par` is used to wrap parenthesis around labels (`LitLabel`),
if they occur in a context requiring an atomic thing (for example function
application).

Although not all Core literals would be valid Haskell, we are trying to stay
as close as possible to Haskell syntax in the printing of Core, to make it
easier for a Haskell user to read Core.

To that end:
  * We do print parenthesis around negative `LitInteger`, because we print
  `LitInteger` using plain number literals (no prefix or suffix), and plain
  number literals in Haskell require parenthesis in contexts like function
  application (i.e. `1 - -1` is not valid Haskell).

  * We don't print parenthesis around other (negative) literals, because they
  aren't needed in GHC/Haskell either (i.e. `1# -# -1#` is accepted by GHC's
  parser).

Literal         Output             Output if context requires
                                   an atom (if different)
-------         -------            ----------------------
LitChar         'a'#
LitString       "aaa"#
LitNullAddr     "__NULL"
LitInt          -1#
LitIntN         -1#N
LitWord          1##
LitWordN         1##N
LitFloat        -1.0#
LitDouble       -1.0##
LitBigNat       1
LitLabel        "__label" ...      ("__label" ...)
LitRubbish      "RUBBISH[...]"

Note [Rubbish literals]
~~~~~~~~~~~~~~~~~~~~~~~
Sometimes, we need to cough up a rubbish value of a certain type that is used
in place of dead code we thus aim to eliminate. The value of a dead occurrence
has no effect on the dynamic semantics of the program, so we can pick any value
of the same representation.

Exploiting the results of absence analysis in worker/wrapper is a scenario where
we need such a rubbish value, see examples in Note [Absent fillers] in
GHC.Core.Opt.WorkWrap.Utils.

It's completely undefined what the *value* of a rubbish value is, e.g., we could
pick @0#@ for @Int#@ or @42#@; it mustn't matter where it's inserted into a Core
program. We embed these rubbish values in the 'LitRubbish' case of the 'Literal'
data type. Here are the moving parts:

1. Source Haskell: No way to produce rubbish lits in source syntax. Purely
   an IR feature.

2. Core: 'LitRubbish' carries a `Type` of kind RuntimeRep,
   describing the runtime representation of the literal (is it a
   pointer, an unboxed Double#, or whatever).

   We have it that `RUBBISH[rr]` has type `forall (a :: TYPE rr). a`.
   See the `LitRubbish` case of `literalType`.

   The function GHC.Core.Make.mkLitRubbish makes a Core rubbish literal of
   a given type.  It obeys the following invariants:

   INVARIANT 1: 'rr' has no free variables. Main reason: we don't need to run
   substitutions and free variable finders over Literal. The rules around
   levity/runtime-rep polymorphism naturally uphold this invariant.

   INVARIANT 2: we never make a rubbish literal of type (a ~# b). Reason:
   see Note [Core type and coercion invariant] in GHC.Core.  We can't substitute
   a LitRubbish inside a coercion, so it's best not to make one. They are zero
   width anyway, so passing absent ones around costs nothing.  If we wanted
   an absent filler of type (a ~# b) we should use (Coercion (UnivCo ...)),
   but it doesn't seem worth making a new UnivCoProvenance for this purpose.

   This is sad, though: see #18983.

3. STG: The type app in `RUBBISH[IntRep] @Int# :: Int#` is erased and we get
   the (untyped) 'StgLit' `RUBBISH[IntRep] :: Int#` in STG.

   It's treated mostly opaque, with the exception of the Unariser, where we
   take apart a case scrutinisation on, or arg occurrence of, e.g.,
   `RUBBISH[TupleRep[IntRep,DoubleRep]]` (which may stand in for `(# Int#, Double# #)`)
   into its sub-parts `RUBBISH[IntRep]` and `RUBBISH[DoubleRep]`, similar to
   unboxed tuples.

   See 'unariseLiteral_maybe' and also Note [Post-unarisation invariants].

4. Cmm: We translate 'LitRubbish' to their actual rubbish value in 'cgLit'.
   The particulars are boring, and only matter when debugging illicit use of
   a rubbish value; see Modes of failure below.

5. Bytecode: In GHC.ByteCode.Asm we just lower it as a 0 literal, because it's
   all boxed to the host GC anyway.

6. IfaceSyn: `Literal` is part of `IfaceSyn`, but `Type` really isn't.  So in
   the passage from Core to Iface we put LitRubbish into its own IfaceExpr data
   constructor, IfaceLitRubbish. The remaining constructors of Literal are
   fine as IfaceSyn.

Wrinkles

a) Why do we put the `Type` (of kind RuntimeRep) inside the literal?  Could
   we not instead /apply/ the literal to that RuntimeRep?  Alas no, because
   then LitRubbish :: forall (rr::RuntimeRep) (a::TYPE rr). a
   and that's an ill-formed type because its kind is `TYPE rr`, which escapes
   the binding site of `rr`. Annoying.

b) A rubbish literal is not bottom, and replies True to exprOkForSpeculation.
   For unboxed types there is no bottom anyway.  If we have
       let (x::Int#) = RUBBISH[IntRep] @Int#
   we want to convert that to a case!  We want to leave it as a let, and
   probably discard it as dead code soon after because x is unused.

c) We can see a rubbish literal at the head of an application chain.
   Most obviously, pretty much every rubbish literal is the head of a
   type application e.g. `RUBBISH[IntRep] @Int#`.  But see also
   Note [How a rubbish literal can be the head of an application]

c) Literal is in Ord, because (and only because) we use Ord on AltCon when
   building a TypeMap. Annoying.  We use `nonDetCmpType` here; the
   non-determinism won't matter because it's only used in TrieMap.
   Moreover, rubbish literals should not appear in patterns anyway.

d) Why not lower LitRubbish in CoreToStg? Because it enables us to use
   LitRubbish when unarising unboxed sums in the future, and it allows
   rubbish values of e.g.  VecRep, for which we can't cough up dummy
   values in STG.

Modes of failure
----------------
Suppose there is a bug in GHC, and a rubbish value is used after all. That is
undefined behavior, of course, but let us list a few examples for failure modes:

 a) For an value of unboxed numeric type like `Int#`, we just use a silly
    value like 42#. The error might propagate indefinitely, hence we better
    pick a rather unique literal. Same for Word, Floats, Char and VecRep.
 b) For AddrRep (like String lits), we emit a null pointer, resulting in a
    definitive segfault when accessed.
 c) For boxed values, unlifted or not, we use a pointer to a fixed closure,
    like `()`, so that the GC has a pointer to follow.
    If we use that pointer as an 'Array#', we will likely access fields of the
    array that don't exist, and a seg-fault is likely, but not guaranteed.
    If we use that pointer as `Either Int Bool`, we might try to access the
    'Int' field of the 'Left' constructor (which has the same ConTag as '()'),
    which doesn't exists. In the best case, we'll find an invalid pointer in its
    position and get a seg-fault, in the worst case the error manifests only one
    or two indirections later.

Note [How a rubbish literal can be the head of an application]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this (#19824):

    h :: T3 -> Int -> blah
    h _ (I# n) = ...

    f :: (T1 -> T2 -> T3) -> T4 -> blah
    f g x = ....(h (g n s) x)...

Demand analysis finds that h does not use its first argument, and w/w's h to

    {-# INLINE h #-}
    h a b = case b of I# n -> $wh n

Demand analysis also finds that f does not use its first arg,
so the worker for f look like

    $wf x = let g = RUBBISH in
            ....(h (g n s) x)...

Now we inline g to get:

    $wf x = ....(h (RUBBISH n s) x)...

And lo, until we inline `h`, we have that application of
RUBBISH in $wf's RHS.  But surely `h` will inline? Not if the
arguments look boring.  Well, RUBBISH doesn't look boring.  But it
could be a bit more complicated like
   f g x = let t = ...(g n s)...
           in ...(h t x)...

and now the call looks more boring.  Anyway, the point is that we
might reasonably see RUBBISH at the head of an application chain.

It would be fine to rewrite
  RUBBISH @(ta->tb->tr) a b  --->   RUBBISH @tr
but we don't currently do so.

It is NOT ok to discard the entire continuation:
  case RUBBISH @ty of DEFAULT -> blah
does not return RUBBISH!
-}