Capture original source for literals
[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 import Lexer       ( SourceText )
28
29 import Data.ByteString (ByteString)
30 import Data.Data hiding ( Fixity )
31 \end{code}
32
33
34
35
36
37 %************************************************************************
38 %*                                                                      *
39 \subsection[HsLit]{Literals}
40 %*                                                                      *
41 %************************************************************************
42
43
44 \begin{code}
45 -- Note [literal source text] for SourceText fields in the following
46 data HsLit
47   = HsChar          SourceText Char        -- Character
48   | HsCharPrim      SourceText Char        -- Unboxed character
49   | HsString        SourceText FastString  -- String
50   | HsStringPrim    SourceText ByteString  -- Packed bytes
51   | HsInt           SourceText Integer     -- Genuinely an Int; arises from
52                                        --     TcGenDeriv, and from TRANSLATION
53   | HsIntPrim       SourceText Integer     -- literal Int#
54   | HsWordPrim      SourceText Integer     -- literal Word#
55   | HsInt64Prim     SourceText Integer     -- literal Int64#
56   | HsWord64Prim    SourceText Integer     -- literal Word64#
57   | HsInteger       SourceText Integer Type -- Genuinely an integer; arises only
58                                           --   from TRANSLATION (overloaded
59                                           --   literals are done with HsOverLit)
60   | HsRat           FractionalLit Type -- Genuinely a rational; arises only from
61                                        --   TRANSLATION (overloaded literals are
62                                        --   done with HsOverLit)
63   | HsFloatPrim     FractionalLit      -- Unboxed Float
64   | HsDoublePrim    FractionalLit      -- Unboxed Double
65   deriving (Data, Typeable)
66
67 instance Eq HsLit where
68   (HsChar _ x1)       == (HsChar _ x2)       = x1==x2
69   (HsCharPrim _ x1)   == (HsCharPrim _ x2)   = x1==x2
70   (HsString _ x1)     == (HsString _ x2)     = x1==x2
71   (HsStringPrim _ x1) == (HsStringPrim _ x2) = x1==x2
72   (HsInt _ x1)        == (HsInt _ x2)        = x1==x2
73   (HsIntPrim _ x1)    == (HsIntPrim _ x2)    = x1==x2
74   (HsWordPrim _ x1)   == (HsWordPrim _ x2)   = x1==x2
75   (HsInt64Prim _ x1)  == (HsInt64Prim _ x2)  = x1==x2
76   (HsWord64Prim _ x1) == (HsWord64Prim _ x2) = x1==x2
77   (HsInteger _ x1 _)  == (HsInteger _ x2 _)  = x1==x2
78   (HsRat x1 _)        == (HsRat x2 _)        = x1==x2
79   (HsFloatPrim x1)    == (HsFloatPrim x2)    = x1==x2
80   (HsDoublePrim x1)   == (HsDoublePrim x2)   = x1==x2
81   _                   == _                   = False
82
83 data HsOverLit id       -- An overloaded literal
84   = OverLit {
85         ol_val :: OverLitVal,
86         ol_rebindable :: PostRn id Bool, -- Note [ol_rebindable]
87         ol_witness :: SyntaxExpr id,     -- Note [Overloaded literal witnesses]
88         ol_type :: PostTc id Type }
89   deriving (Typeable)
90 deriving instance (DataId id) => Data (HsOverLit id)
91
92 -- Note [literal source text] for SourceText fields in the following
93 data OverLitVal
94   = HsIntegral   !SourceText !Integer    -- Integer-looking literals;
95   | HsFractional !FractionalLit          -- Frac-looking literals
96   | HsIsString   !SourceText !FastString -- String-looking literals
97   deriving (Data, Typeable)
98
99 overLitType :: HsOverLit a -> PostTc a Type
100 overLitType = ol_type
101 \end{code}
102
103 Note [literal source text]
104 ~~~~~~~~~~~~~~~~~~~~~~~~~~
105
106 The lexer/parser converts literals from their original source text
107 versions to an appropriate internal representation. This is a problem
108 for tools doing source to source conversions, so the original source
109 text is stored in literals where this can occur.
110
111 Motivating examples for HsLit
112
113   HsChar          '\n', '\x20`
114   HsCharPrim      '\x41`#
115   HsString        "\x20\x41" == " A"
116   HsStringPrim    "\x20"#
117   HsInt           001
118   HsIntPrim       002#
119   HsWordPrim      003##
120   HsInt64Prim     004##
121   HsWord64Prim    005##
122   HsInteger       006
123
124 For OverLitVal
125
126   HsIntegral      003,0x001
127   HsIsString      "\x41nd"
128
129
130
131
132
133 Note [ol_rebindable]
134 ~~~~~~~~~~~~~~~~~~~~
135 The ol_rebindable field is True if this literal is actually
136 using rebindable syntax.  Specifically:
137
138   False iff ol_witness is the standard one
139   True  iff ol_witness is non-standard
140
141 Equivalently it's True if
142   a) RebindableSyntax is on
143   b) the witness for fromInteger/fromRational/fromString
144      that happens to be in scope isn't the standard one
145
146 Note [Overloaded literal witnesses]
147 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
148 *Before* type checking, the SyntaxExpr in an HsOverLit is the
149 name of the coercion function, 'fromInteger' or 'fromRational'.
150 *After* type checking, it is a witness for the literal, such as
151         (fromInteger 3) or lit_78
152 This witness should replace the literal.
153
154 This dual role is unusual, because we're replacing 'fromInteger' with
155 a call to fromInteger.  Reason: it allows commoning up of the fromInteger
156 calls, which wouldn't be possible if the desguarar made the application.
157
158 The PostTcType in each branch records the type the overload literal is
159 found to have.
160
161 \begin{code}
162 -- Comparison operations are needed when grouping literals
163 -- for compiling pattern-matching (module MatchLit)
164 instance Eq (HsOverLit id) where
165   (OverLit {ol_val = val1}) == (OverLit {ol_val=val2}) = val1 == val2
166
167 instance Eq OverLitVal where
168   (HsIntegral _ i1)   == (HsIntegral _ i2)   = i1 == i2
169   (HsFractional f1)   == (HsFractional f2)   = f1 == f2
170   (HsIsString _ s1)   == (HsIsString _ s2)   = s1 == s2
171   _                   == _                   = False
172
173 instance Ord (HsOverLit id) where
174   compare (OverLit {ol_val=val1}) (OverLit {ol_val=val2}) = val1 `compare` val2
175
176 instance Ord OverLitVal where
177   compare (HsIntegral _ i1)   (HsIntegral _ i2)   = i1 `compare` i2
178   compare (HsIntegral _ _)    (HsFractional _)    = LT
179   compare (HsIntegral _ _)    (HsIsString _ _)    = LT
180   compare (HsFractional f1)   (HsFractional f2)   = f1 `compare` f2
181   compare (HsFractional _)    (HsIntegral _ _)    = GT
182   compare (HsFractional _)    (HsIsString _ _)    = LT
183   compare (HsIsString _ s1)   (HsIsString _ s2)   = s1 `compare` s2
184   compare (HsIsString _ _)    (HsIntegral _ _)    = GT
185   compare (HsIsString _ _)    (HsFractional _)    = GT
186 \end{code}
187
188 \begin{code}
189 instance Outputable HsLit where
190         -- Use "show" because it puts in appropriate escapes
191     ppr (HsChar _ c)       = pprHsChar c
192     ppr (HsCharPrim _ c)   = pprHsChar c <> char '#'
193     ppr (HsString _ s)     = pprHsString s
194     ppr (HsStringPrim _ s) = pprHsBytes s <> char '#'
195     ppr (HsInt _ i)        = integer i
196     ppr (HsInteger _ i _)  = integer i
197     ppr (HsRat f _)        = ppr f
198     ppr (HsFloatPrim f)    = ppr f <> char '#'
199     ppr (HsDoublePrim d)   = ppr d <> text "##"
200     ppr (HsIntPrim _ i)    = integer i  <> char '#'
201     ppr (HsWordPrim _ w)   = integer w  <> text "##"
202     ppr (HsInt64Prim _ i)  = integer i  <> text "L#"
203     ppr (HsWord64Prim _ w) = integer w  <> text "L##"
204
205 -- in debug mode, print the expression that it's resolved to, too
206 instance OutputableBndr id => Outputable (HsOverLit id) where
207   ppr (OverLit {ol_val=val, ol_witness=witness})
208         = ppr val <+> (ifPprDebug (parens (pprExpr witness)))
209
210 instance Outputable OverLitVal where
211   ppr (HsIntegral _ i)   = integer i
212   ppr (HsFractional f)   = ppr f
213   ppr (HsIsString _ s)   = pprHsString s
214 \end{code}