db6e126594675efab1a4d0cef2d8be5614366de7
[ghc.git] / compiler / hsSyn / HsLit.lhs
1 %
2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
4 %
5 \section[HsLit]{Abstract syntax: source-language literals}
6
7 \begin{code}
8 {-# LANGUAGE CPP, DeriveDataTypeable #-}
9 {-# LANGUAGE TypeSynonymInstances #-}
10 {-# LANGUAGE StandaloneDeriving #-}
11 {-# LANGUAGE FlexibleInstances #-}
12 {-# LANGUAGE FlexibleContexts #-}
13 {-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]
14                                       -- in module PlaceHolder
15 {-# LANGUAGE ConstraintKinds #-}
16
17 module HsLit where
18
19 #include "HsVersions.h"
20
21 import {-# SOURCE #-} HsExpr( SyntaxExpr, pprExpr )
22 import BasicTypes ( FractionalLit(..) )
23 import Type       ( Type )
24 import Outputable
25 import FastString
26 import PlaceHolder ( PostTc,PostRn,DataId )
27
28 import Data.ByteString (ByteString)
29 import Data.Data hiding ( Fixity )
30 \end{code}
31
32
33
34
35
36 %************************************************************************
37 %*                                                                      *
38 \subsection[HsLit]{Literals}
39 %*                                                                      *
40 %************************************************************************
41
42
43 \begin{code}
44 data HsLit
45   = HsChar          Char               -- Character
46   | HsCharPrim      Char               -- Unboxed character
47   | HsString        FastString         -- String
48   | HsStringPrim    ByteString         -- Packed bytes
49   | HsInt           Integer            -- Genuinely an Int; arises from
50                                        --     TcGenDeriv, and from TRANSLATION
51   | HsIntPrim       Integer            -- literal Int#
52   | HsWordPrim      Integer            -- literal Word#
53   | HsInt64Prim     Integer            -- literal Int64#
54   | HsWord64Prim    Integer            -- literal Word64#
55   | HsInteger       Integer  Type      -- Genuinely an integer; arises only from
56                                        --   TRANSLATION (overloaded literals are
57                                        --   done with HsOverLit)
58   | HsRat           FractionalLit Type -- Genuinely a rational; arises only from
59                                        --   TRANSLATION (overloaded literals are
60                                        --   done with HsOverLit)
61   | HsFloatPrim     FractionalLit      -- Unboxed Float
62   | HsDoublePrim    FractionalLit      -- Unboxed Double
63   deriving (Data, Typeable)
64
65 instance Eq HsLit where
66   (HsChar x1)       == (HsChar x2)       = x1==x2
67   (HsCharPrim x1)   == (HsCharPrim x2)   = x1==x2
68   (HsString x1)     == (HsString x2)     = x1==x2
69   (HsStringPrim x1) == (HsStringPrim x2) = x1==x2
70   (HsInt x1)        == (HsInt x2)        = x1==x2
71   (HsIntPrim x1)    == (HsIntPrim x2)    = x1==x2
72   (HsWordPrim x1)   == (HsWordPrim x2)   = x1==x2
73   (HsInt64Prim x1)  == (HsInt64Prim x2)  = x1==x2
74   (HsWord64Prim x1) == (HsWord64Prim x2) = x1==x2
75   (HsInteger x1 _)  == (HsInteger x2 _)  = x1==x2
76   (HsRat x1 _)      == (HsRat x2 _)      = x1==x2
77   (HsFloatPrim x1)  == (HsFloatPrim x2)  = x1==x2
78   (HsDoublePrim x1) == (HsDoublePrim x2) = x1==x2
79   _                 == _                 = False
80
81 data HsOverLit id       -- An overloaded literal
82   = OverLit {
83         ol_val :: OverLitVal,
84         ol_rebindable :: PostRn id Bool, -- Note [ol_rebindable]
85         ol_witness :: SyntaxExpr id,     -- Note [Overloaded literal witnesses]
86         ol_type :: PostTc id Type }
87   deriving (Typeable)
88 deriving instance (DataId id) => Data (HsOverLit id)
89
90 data OverLitVal
91   = HsIntegral   !Integer       -- Integer-looking literals;
92   | HsFractional !FractionalLit -- Frac-looking literals
93   | HsIsString   !FastString    -- String-looking literals
94   deriving (Data, Typeable)
95
96 overLitType :: HsOverLit a -> PostTc a Type
97 overLitType = ol_type
98 \end{code}
99
100 Note [ol_rebindable]
101 ~~~~~~~~~~~~~~~~~~~~
102 The ol_rebindable field is True if this literal is actually
103 using rebindable syntax.  Specifically:
104
105   False iff ol_witness is the standard one
106   True  iff ol_witness is non-standard
107
108 Equivalently it's True if
109   a) RebindableSyntax is on
110   b) the witness for fromInteger/fromRational/fromString
111      that happens to be in scope isn't the standard one
112
113 Note [Overloaded literal witnesses]
114 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
115 *Before* type checking, the SyntaxExpr in an HsOverLit is the
116 name of the coercion function, 'fromInteger' or 'fromRational'.
117 *After* type checking, it is a witness for the literal, such as
118         (fromInteger 3) or lit_78
119 This witness should replace the literal.
120
121 This dual role is unusual, because we're replacing 'fromInteger' with
122 a call to fromInteger.  Reason: it allows commoning up of the fromInteger
123 calls, which wouldn't be possible if the desguarar made the application.
124
125 The PostTcType in each branch records the type the overload literal is
126 found to have.
127
128 \begin{code}
129 -- Comparison operations are needed when grouping literals
130 -- for compiling pattern-matching (module MatchLit)
131 instance Eq (HsOverLit id) where
132   (OverLit {ol_val = val1}) == (OverLit {ol_val=val2}) = val1 == val2
133
134 instance Eq OverLitVal where
135   (HsIntegral i1)   == (HsIntegral i2)   = i1 == i2
136   (HsFractional f1) == (HsFractional f2) = f1 == f2
137   (HsIsString s1)   == (HsIsString s2)   = s1 == s2
138   _                 == _                 = False
139
140 instance Ord (HsOverLit id) where
141   compare (OverLit {ol_val=val1}) (OverLit {ol_val=val2}) = val1 `compare` val2
142
143 instance Ord OverLitVal where
144   compare (HsIntegral i1)   (HsIntegral i2)   = i1 `compare` i2
145   compare (HsIntegral _)    (HsFractional _)  = LT
146   compare (HsIntegral _)    (HsIsString _)    = LT
147   compare (HsFractional f1) (HsFractional f2) = f1 `compare` f2
148   compare (HsFractional _)  (HsIntegral _)    = GT
149   compare (HsFractional _)  (HsIsString _)    = LT
150   compare (HsIsString s1)   (HsIsString s2)   = s1 `compare` s2
151   compare (HsIsString _)    (HsIntegral _)    = GT
152   compare (HsIsString _)    (HsFractional _)  = GT
153 \end{code}
154
155 \begin{code}
156 instance Outputable HsLit where
157         -- Use "show" because it puts in appropriate escapes
158     ppr (HsChar c)       = pprHsChar c
159     ppr (HsCharPrim c)   = pprHsChar c <> char '#'
160     ppr (HsString s)     = pprHsString s
161     ppr (HsStringPrim s) = pprHsBytes s <> char '#'
162     ppr (HsInt i)        = integer i
163     ppr (HsInteger i _)  = integer i
164     ppr (HsRat f _)      = ppr f
165     ppr (HsFloatPrim f)  = ppr f <> char '#'
166     ppr (HsDoublePrim d) = ppr d <> text "##"
167     ppr (HsIntPrim i)    = integer i  <> char '#'
168     ppr (HsWordPrim w)   = integer w  <> text "##"
169     ppr (HsInt64Prim i)  = integer i  <> text "L#"
170     ppr (HsWord64Prim w) = integer w  <> text "L##"
171
172 -- in debug mode, print the expression that it's resolved to, too
173 instance OutputableBndr id => Outputable (HsOverLit id) where
174   ppr (OverLit {ol_val=val, ol_witness=witness})
175         = ppr val <+> (ifPprDebug (parens (pprExpr witness)))
176
177 instance Outputable OverLitVal where
178   ppr (HsIntegral i)   = integer i
179   ppr (HsFractional f) = ppr f
180   ppr (HsIsString s)   = pprHsString s
181 \end{code}