8a41fa49837ffbb78f00ec6da1db3243425effe2
[ghc.git] / compiler / parser / Parser.y.pp
1 --                                                              -*-haskell-*-
2 -- ---------------------------------------------------------------------------
3 -- (c) The University of Glasgow 1997-2003
4 ---
5 -- The GHC grammar.
6 --
7 -- Author(s): Simon Marlow, Sven Panne 1997, 1998, 1999
8 -- ---------------------------------------------------------------------------
9
10 {
11 {-# LANGUAGE BangPatterns #-} -- required for versions of Happy before 1.18.6
12 {-# OPTIONS -Wwarn -w #-}
13 -- The above warning supression flag is a temporary kludge.
14 -- While working on this module you are encouraged to remove it and fix
15 -- any warnings in the module. See
16 --     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
17 -- for details
18
19 {-# OPTIONS_GHC -O0 -fno-ignore-interface-pragmas #-}
20 {-
21 Careful optimisation of the parser: we don't want to throw everything
22 at it, because that takes too long and doesn't buy much, but we do want
23 to inline certain key external functions, so we instruct GHC not to
24 throw away inlinings as it would normally do in -O0 mode.
25 -}
26
27 module Parser ( parseModule, parseStmt, parseIdentifier, parseType,
28                 parseHeader ) where
29
30 import HsSyn
31 import RdrHsSyn
32 import HscTypes         ( IsBootInterface, WarningTxt(..) )
33 import Lexer
34 import RdrName
35 import TcEvidence       ( emptyTcEvBinds )
36 import TysPrim          ( liftedTypeKindTyConName, eqPrimTyCon )
37 import TysWiredIn       ( unitTyCon, unitDataCon, tupleTyCon, tupleCon, nilDataCon,
38                           unboxedUnitTyCon, unboxedUnitDataCon,
39                           listTyCon_RDR, parrTyCon_RDR, consDataCon_RDR, eqTyCon_RDR )
40 import Type             ( funTyCon )
41 import ForeignCall      ( Safety(..), CExportSpec(..), CLabelString,
42                           CCallConv(..), CCallTarget(..), defaultCCallConv
43                         )
44 import OccName          ( varName, dataName, tcClsName, tvName )
45 import DataCon          ( DataCon, dataConName )
46 import SrcLoc
47 import Module
48 import StaticFlags      ( opt_SccProfilingOn, opt_Hpc )
49 import Kind             ( Kind, liftedTypeKind, unliftedTypeKind, mkArrowKind )
50 import Class            ( FunDep )
51 import BasicTypes
52 import DynFlags
53 import OrdList
54 import HaddockUtils
55
56 import FastString
57 import Maybes           ( orElse )
58 import Outputable
59
60 import Control.Monad    ( unless )
61 import GHC.Exts
62 import Data.Char
63 import Control.Monad    ( mplus )
64 }
65
66 {-
67 -----------------------------------------------------------------------------
68 24 Februar 2006
69
70 Conflicts: 33 shift/reduce
71            1 reduce/reduce
72
73 The reduce/reduce conflict is weird.  It's between tyconsym and consym, and I
74 would think the two should never occur in the same context.
75
76   -=chak
77
78 -----------------------------------------------------------------------------
79 31 December 2006
80
81 Conflicts: 34 shift/reduce
82            1 reduce/reduce
83
84 The reduce/reduce conflict is weird.  It's between tyconsym and consym, and I
85 would think the two should never occur in the same context.
86
87   -=chak
88
89 -----------------------------------------------------------------------------
90 6 December 2006
91
92 Conflicts: 32 shift/reduce
93            1 reduce/reduce
94
95 The reduce/reduce conflict is weird.  It's between tyconsym and consym, and I
96 would think the two should never occur in the same context.
97
98   -=chak
99
100 -----------------------------------------------------------------------------
101 26 July 2006
102
103 Conflicts: 37 shift/reduce
104            1 reduce/reduce
105
106 The reduce/reduce conflict is weird.  It's between tyconsym and consym, and I
107 would think the two should never occur in the same context.
108
109   -=chak
110
111 -----------------------------------------------------------------------------
112 Conflicts: 38 shift/reduce (1.25)
113
114 10 for abiguity in 'if x then y else z + 1'             [State 178]
115         (shift parses as 'if x then y else (z + 1)', as per longest-parse rule)
116         10 because op might be: : - ! * . `x` VARSYM CONSYM QVARSYM QCONSYM
117
118 1 for ambiguity in 'if x then y else z :: T'            [State 178]
119         (shift parses as 'if x then y else (z :: T)', as per longest-parse rule)
120
121 4 for ambiguity in 'if x then y else z -< e'            [State 178]
122         (shift parses as 'if x then y else (z -< T)', as per longest-parse rule)
123         There are four such operators: -<, >-, -<<, >>-
124
125
126 2 for ambiguity in 'case v of { x :: T -> T ... } '     [States 11, 253]
127         Which of these two is intended?
128           case v of
129             (x::T) -> T         -- Rhs is T
130     or
131           case v of
132             (x::T -> T) -> ..   -- Rhs is ...
133
134 10 for ambiguity in 'e :: a `b` c'.  Does this mean     [States 11, 253]
135         (e::a) `b` c, or 
136         (e :: (a `b` c))
137     As well as `b` we can have !, VARSYM, QCONSYM, and CONSYM, hence 5 cases
138     Same duplication between states 11 and 253 as the previous case
139
140 1 for ambiguity in 'let ?x ...'                         [State 329]
141         the parser can't tell whether the ?x is the lhs of a normal binding or
142         an implicit binding.  Fortunately resolving as shift gives it the only
143         sensible meaning, namely the lhs of an implicit binding.
144
145 1 for ambiguity in '{-# RULES "name" [ ... #-}          [State 382]
146         we don't know whether the '[' starts the activation or not: it
147         might be the start of the declaration with the activation being
148         empty.  --SDM 1/4/2002
149
150 1 for ambiguity in '{-# RULES "name" forall = ... #-}'  [State 474]
151         since 'forall' is a valid variable name, we don't know whether
152         to treat a forall on the input as the beginning of a quantifier
153         or the beginning of the rule itself.  Resolving to shift means
154         it's always treated as a quantifier, hence the above is disallowed.
155         This saves explicitly defining a grammar for the rule lhs that
156         doesn't include 'forall'.
157
158 1 for ambiguity when the source file starts with "-- | doc". We need another
159   token of lookahead to determine if a top declaration or the 'module' keyword
160   follows. Shift parses as if the 'module' keyword follows.   
161
162 -- ---------------------------------------------------------------------------
163 -- Adding location info
164
165 This is done in a stylised way using the three macros below, L0, L1
166 and LL.  Each of these macros can be thought of as having type
167
168    L0, L1, LL :: a -> Located a
169
170 They each add a SrcSpan to their argument.
171
172    L0   adds 'noSrcSpan', used for empty productions
173      -- This doesn't seem to work anymore -=chak
174
175    L1   for a production with a single token on the lhs.  Grabs the SrcSpan
176         from that token.
177
178    LL   for a production with >1 token on the lhs.  Makes up a SrcSpan from
179         the first and last tokens.
180
181 These suffice for the majority of cases.  However, we must be
182 especially careful with empty productions: LL won't work if the first
183 or last token on the lhs can represent an empty span.  In these cases,
184 we have to calculate the span using more of the tokens from the lhs, eg.
185
186         | 'newtype' tycl_hdr '=' newconstr deriving
187                 { L (comb3 $1 $4 $5)
188                     (mkTyData NewType (unLoc $2) [$4] (unLoc $5)) }
189
190 We provide comb3 and comb4 functions which are useful in such cases.
191
192 Be careful: there's no checking that you actually got this right, the
193 only symptom will be that the SrcSpans of your syntax will be
194 incorrect.
195
196 /*
197  * We must expand these macros *before* running Happy, which is why this file is
198  * Parser.y.pp rather than just Parser.y - we run the C pre-processor first.
199  */
200 #define L0   L noSrcSpan
201 #define L1   sL (getLoc $1)
202 #define LL   sL (comb2 $1 $>)
203
204 -- -----------------------------------------------------------------------------
205
206 -}
207
208 %token
209  '_'            { L _ ITunderscore }            -- Haskell keywords
210  'as'           { L _ ITas }
211  'case'         { L _ ITcase }          
212  'class'        { L _ ITclass } 
213  'data'         { L _ ITdata } 
214  'default'      { L _ ITdefault }
215  'deriving'     { L _ ITderiving }
216  'do'           { L _ ITdo }
217  'else'         { L _ ITelse }
218  'hiding'       { L _ IThiding }
219  'if'           { L _ ITif }
220  'import'       { L _ ITimport }
221  'in'           { L _ ITin }
222  'infix'        { L _ ITinfix }
223  'infixl'       { L _ ITinfixl }
224  'infixr'       { L _ ITinfixr }
225  'instance'     { L _ ITinstance }
226  'let'          { L _ ITlet }
227  'module'       { L _ ITmodule }
228  'newtype'      { L _ ITnewtype }
229  'of'           { L _ ITof }
230  'qualified'    { L _ ITqualified }
231  'then'         { L _ ITthen }
232  'type'         { L _ ITtype }
233  'where'        { L _ ITwhere }
234  '_scc_'        { L _ ITscc }         -- ToDo: remove
235
236  'forall'       { L _ ITforall }                -- GHC extension keywords
237  'foreign'      { L _ ITforeign }
238  'export'       { L _ ITexport }
239  'label'        { L _ ITlabel } 
240  'dynamic'      { L _ ITdynamic }
241  'safe'         { L _ ITsafe }
242  'interruptible' { L _ ITinterruptible }
243  'unsafe'       { L _ ITunsafe }
244  'mdo'          { L _ ITmdo }
245  'family'       { L _ ITfamily }
246  'stdcall'      { L _ ITstdcallconv }
247  'ccall'        { L _ ITccallconv }
248  'capi'         { L _ ITcapiconv }
249  'prim'         { L _ ITprimcallconv }
250  'proc'         { L _ ITproc }          -- for arrow notation extension
251  'rec'          { L _ ITrec }           -- for arrow notation extension
252  'group'    { L _ ITgroup }     -- for list transform extension
253  'by'       { L _ ITby }        -- for list transform extension
254  'using'    { L _ ITusing }     -- for list transform extension
255
256  '{-# INLINE'             { L _ (ITinline_prag _ _) }
257  '{-# SPECIALISE'         { L _ ITspec_prag }
258  '{-# SPECIALISE_INLINE'  { L _ (ITspec_inline_prag _) }
259  '{-# SOURCE'                                   { L _ ITsource_prag }
260  '{-# RULES'                                    { L _ ITrules_prag }
261  '{-# CORE'                                     { L _ ITcore_prag }              -- hdaume: annotated core
262  '{-# SCC'                { L _ ITscc_prag }
263  '{-# GENERATED'          { L _ ITgenerated_prag }
264  '{-# DEPRECATED'         { L _ ITdeprecated_prag }
265  '{-# WARNING'            { L _ ITwarning_prag }
266  '{-# UNPACK'             { L _ ITunpack_prag }
267  '{-# NOUNPACK'           { L _ ITnounpack_prag }
268  '{-# ANN'                { L _ ITann_prag }
269  '{-# VECTORISE'          { L _ ITvect_prag }
270  '{-# VECTORISE_SCALAR'   { L _ ITvect_scalar_prag }
271  '{-# NOVECTORISE'        { L _ ITnovect_prag }
272  '#-}'                                          { L _ ITclose_prag }
273
274  '..'           { L _ ITdotdot }                        -- reserved symbols
275  ':'            { L _ ITcolon }
276  '::'           { L _ ITdcolon }
277  '='            { L _ ITequal }
278  '\\'           { L _ ITlam }
279  '|'            { L _ ITvbar }
280  '<-'           { L _ ITlarrow }
281  '->'           { L _ ITrarrow }
282  '@'            { L _ ITat }
283  '~'            { L _ ITtilde }
284  '~#'           { L _ ITtildehsh }
285  '=>'           { L _ ITdarrow }
286  '-'            { L _ ITminus }
287  '!'            { L _ ITbang }
288  '*'            { L _ ITstar }
289  '-<'           { L _ ITlarrowtail }            -- for arrow notation
290  '>-'           { L _ ITrarrowtail }            -- for arrow notation
291  '-<<'          { L _ ITLarrowtail }            -- for arrow notation
292  '>>-'          { L _ ITRarrowtail }            -- for arrow notation
293  '.'            { L _ ITdot }
294
295  '{'            { L _ ITocurly }                        -- special symbols
296  '}'            { L _ ITccurly }
297  '{|'           { L _ ITocurlybar }
298  '|}'           { L _ ITccurlybar }
299  vocurly        { L _ ITvocurly } -- virtual open curly (from layout)
300  vccurly        { L _ ITvccurly } -- virtual close curly (from layout)
301  '['            { L _ ITobrack }
302  ']'            { L _ ITcbrack }
303  '[:'           { L _ ITopabrack }
304  ':]'           { L _ ITcpabrack }
305  '('            { L _ IToparen }
306  ')'            { L _ ITcparen }
307  '(#'           { L _ IToubxparen }
308  '#)'           { L _ ITcubxparen }
309  '(|'           { L _ IToparenbar }
310  '|)'           { L _ ITcparenbar }
311  ';'            { L _ ITsemi }
312  ','            { L _ ITcomma }
313  '`'            { L _ ITbackquote }
314  SIMPLEQUOTE    { L _ ITsimpleQuote      }     -- 'x
315
316  VARID          { L _ (ITvarid    _) }          -- identifiers
317  CONID          { L _ (ITconid    _) }
318  VARSYM         { L _ (ITvarsym   _) }
319  CONSYM         { L _ (ITconsym   _) }
320  QVARID         { L _ (ITqvarid   _) }
321  QCONID         { L _ (ITqconid   _) }
322  QVARSYM        { L _ (ITqvarsym  _) }
323  QCONSYM        { L _ (ITqconsym  _) }
324  PREFIXQVARSYM  { L _ (ITprefixqvarsym  _) }
325  PREFIXQCONSYM  { L _ (ITprefixqconsym  _) }
326
327  IPDUPVARID     { L _ (ITdupipvarid   _) }              -- GHC extension
328
329  CHAR           { L _ (ITchar     _) }
330  STRING         { L _ (ITstring   _) }
331  INTEGER        { L _ (ITinteger  _) }
332  RATIONAL       { L _ (ITrational _) }
333                     
334  PRIMCHAR       { L _ (ITprimchar   _) }
335  PRIMSTRING     { L _ (ITprimstring _) }
336  PRIMINTEGER    { L _ (ITprimint    _) }
337  PRIMWORD       { L _ (ITprimword  _) }
338  PRIMFLOAT      { L _ (ITprimfloat  _) }
339  PRIMDOUBLE     { L _ (ITprimdouble _) }
340
341  DOCNEXT        { L _ (ITdocCommentNext _) }
342  DOCPREV        { L _ (ITdocCommentPrev _) }
343  DOCNAMED       { L _ (ITdocCommentNamed _) }
344  DOCSECTION     { L _ (ITdocSection _ _) }
345
346 -- Template Haskell 
347 '[|'            { L _ ITopenExpQuote  }       
348 '[p|'           { L _ ITopenPatQuote  }      
349 '[t|'           { L _ ITopenTypQuote  }      
350 '[d|'           { L _ ITopenDecQuote  }      
351 '|]'            { L _ ITcloseQuote    }
352 TH_ID_SPLICE    { L _ (ITidEscape _)  }     -- $x
353 '$('            { L _ ITparenEscape   }     -- $( exp )
354 TH_TY_QUOTE     { L _ ITtyQuote       }      -- ''T
355 TH_QUASIQUOTE   { L _ (ITquasiQuote _) }
356
357 %monad { P } { >>= } { return }
358 %lexer { lexer } { L _ ITeof }
359 %name parseModule module
360 %name parseStmt   maybe_stmt
361 %name parseIdentifier  identifier
362 %name parseType ctype
363 %partial parseHeader header
364 %tokentype { (Located Token) }
365 %%
366
367 -----------------------------------------------------------------------------
368 -- Identifiers; one of the entry points
369 identifier :: { Located RdrName }
370         : qvar                          { $1 }
371         | qcon                          { $1 }
372         | qvarop                        { $1 }
373         | qconop                        { $1 }
374     | '(' '->' ')'      { LL $ getRdrName funTyCon }
375
376 -----------------------------------------------------------------------------
377 -- Module Header
378
379 -- The place for module deprecation is really too restrictive, but if it
380 -- was allowed at its natural place just before 'module', we get an ugly
381 -- s/r conflict with the second alternative. Another solution would be the
382 -- introduction of a new pragma DEPRECATED_MODULE, but this is not very nice,
383 -- either, and DEPRECATED is only expected to be used by people who really
384 -- know what they are doing. :-)
385
386 module  :: { Located (HsModule RdrName) }
387         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' body
388                 {% fileSrcSpan >>= \ loc ->
389                    return (L loc (HsModule (Just $3) $5 (fst $7) (snd $7) $4 $1
390                           ) )}
391         | body2
392                 {% fileSrcSpan >>= \ loc ->
393                    return (L loc (HsModule Nothing Nothing
394                           (fst $1) (snd $1) Nothing Nothing
395                           )) }
396
397 maybedocheader :: { Maybe LHsDocString }
398         : moduleheader            { $1 }
399         | {- empty -}             { Nothing }
400
401 missing_module_keyword :: { () }
402         : {- empty -}                           {% pushCurrentContext }
403
404 maybemodwarning :: { Maybe WarningTxt }
405     : '{-# DEPRECATED' strings '#-}' { Just (DeprecatedTxt $ unLoc $2) }
406     | '{-# WARNING' strings '#-}'    { Just (WarningTxt $ unLoc $2) }
407     |  {- empty -}                  { Nothing }
408
409 body    :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }
410         :  '{'            top '}'               { $2 }
411         |      vocurly    top close             { $2 }
412
413 body2   :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }
414         :  '{' top '}'                          { $2 }
415         |  missing_module_keyword top close     { $2 }
416
417 top     :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }
418         : importdecls                           { (reverse $1,[]) }
419         | importdecls ';' cvtopdecls            { (reverse $1,$3) }
420         | cvtopdecls                            { ([],$1) }
421
422 cvtopdecls :: { [LHsDecl RdrName] }
423         : topdecls                              { cvTopDecls $1 }
424
425 -----------------------------------------------------------------------------
426 -- Module declaration & imports only
427
428 header  :: { Located (HsModule RdrName) }
429         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' header_body
430                 {% fileSrcSpan >>= \ loc ->
431                    return (L loc (HsModule (Just $3) $5 $7 [] $4 $1
432                           ))}
433         | header_body2
434                 {% fileSrcSpan >>= \ loc ->
435                    return (L loc (HsModule Nothing Nothing $1 [] Nothing
436                           Nothing)) }
437
438 header_body :: { [LImportDecl RdrName] }
439         :  '{'            importdecls           { $2 }
440         |      vocurly    importdecls           { $2 }
441
442 header_body2 :: { [LImportDecl RdrName] }
443         :  '{' importdecls                      { $2 }
444         |  missing_module_keyword importdecls   { $2 }
445
446 -----------------------------------------------------------------------------
447 -- The Export List
448
449 maybeexports :: { Maybe [LIE RdrName] }
450         :  '(' exportlist ')'                   { Just $2 }
451         |  {- empty -}                          { Nothing }
452
453 exportlist :: { [LIE RdrName] }
454         : expdoclist ',' expdoclist             { $1 ++ $3 }
455         | exportlist1                           { $1 }
456
457 exportlist1 :: { [LIE RdrName] }
458         : expdoclist export expdoclist ',' exportlist  { $1 ++ ($2 : $3) ++ $5 }
459         | expdoclist export expdoclist                 { $1 ++ ($2 : $3) }
460         | expdoclist                                   { $1 }
461
462 expdoclist :: { [LIE RdrName] }
463         : exp_doc expdoclist                           { $1 : $2 }
464         | {- empty -}                                  { [] }
465
466 exp_doc :: { LIE RdrName }                                                   
467         : docsection    { L1 (case (unLoc $1) of (n, doc) -> IEGroup n doc) }
468         | docnamed      { L1 (IEDocNamed ((fst . unLoc) $1)) } 
469         | docnext       { L1 (IEDoc (unLoc $1)) }       
470                        
471    -- No longer allow things like [] and (,,,) to be exported
472    -- They are built in syntax, always available
473 export  :: { LIE RdrName }
474         :  qvar                         { L1 (IEVar (unLoc $1)) }
475         |  oqtycon                      { L1 (IEThingAbs (unLoc $1)) }
476         |  oqtycon '(' '..' ')'         { LL (IEThingAll (unLoc $1)) }
477         |  oqtycon '(' ')'              { LL (IEThingWith (unLoc $1) []) }
478         |  oqtycon '(' qcnames ')'      { LL (IEThingWith (unLoc $1) (reverse $3)) }
479         |  'module' modid               { LL (IEModuleContents (unLoc $2)) }
480
481 qcnames :: { [RdrName] }
482         :  qcnames ',' qcname_ext       { unLoc $3 : $1 }
483         |  qcname_ext                   { [unLoc $1]  }
484
485 qcname_ext :: { Located RdrName }       -- Variable or data constructor
486                                         -- or tagged type constructor
487         :  qcname                       { $1 }
488         |  'type' qcon                  { sL (comb2 $1 $2) 
489                                              (setRdrNameSpace (unLoc $2) 
490                                                               tcClsName)  }
491
492 -- Cannot pull into qcname_ext, as qcname is also used in expression.
493 qcname  :: { Located RdrName }  -- Variable or data constructor
494         :  qvar                         { $1 }
495         |  qcon                         { $1 }
496
497 -----------------------------------------------------------------------------
498 -- Import Declarations
499
500 -- import decls can be *empty*, or even just a string of semicolons
501 -- whereas topdecls must contain at least one topdecl.
502
503 importdecls :: { [LImportDecl RdrName] }
504         : importdecls ';' importdecl            { $3 : $1 }
505         | importdecls ';'                       { $1 }
506         | importdecl                            { [ $1 ] }
507         | {- empty -}                           { [] }
508
509 importdecl :: { LImportDecl RdrName }
510         : 'import' maybe_src maybe_safe optqualified maybe_pkg modid maybeas maybeimpspec 
511                 { L (comb4 $1 $6 $7 $8) $
512                   ImportDecl { ideclName = $6, ideclPkgQual = $5
513                              , ideclSource = $2, ideclSafe = $3
514                              , ideclQualified = $4, ideclImplicit = False
515                              , ideclAs = unLoc $7, ideclHiding = unLoc $8 } }
516
517 maybe_src :: { IsBootInterface }
518         : '{-# SOURCE' '#-}'                    { True }
519         | {- empty -}                           { False }
520
521 maybe_safe :: { Bool }
522         : 'safe'                                { True }
523         | {- empty -}                           { False }
524
525 maybe_pkg :: { Maybe FastString }
526         : STRING                                { Just (getSTRING $1) }
527         | {- empty -}                           { Nothing }
528
529 optqualified :: { Bool }
530         : 'qualified'                           { True  }
531         | {- empty -}                           { False }
532
533 maybeas :: { Located (Maybe ModuleName) }
534         : 'as' modid                            { LL (Just (unLoc $2)) }
535         | {- empty -}                           { noLoc Nothing }
536
537 maybeimpspec :: { Located (Maybe (Bool, [LIE RdrName])) }
538         : impspec                               { L1 (Just (unLoc $1)) }
539         | {- empty -}                           { noLoc Nothing }
540
541 impspec :: { Located (Bool, [LIE RdrName]) }
542         :  '(' exportlist ')'                   { LL (False, $2) }
543         |  'hiding' '(' exportlist ')'          { LL (True,  $3) }
544
545 -----------------------------------------------------------------------------
546 -- Fixity Declarations
547
548 prec    :: { Int }
549         : {- empty -}           { 9 }
550         | INTEGER               {% checkPrecP (L1 (fromInteger (getINTEGER $1))) }
551
552 infix   :: { Located FixityDirection }
553         : 'infix'                               { L1 InfixN  }
554         | 'infixl'                              { L1 InfixL  }
555         | 'infixr'                              { L1 InfixR }
556
557 ops     :: { Located [Located RdrName] }
558         : ops ',' op                            { LL ($3 : unLoc $1) }
559         | op                                    { L1 [$1] }
560
561 -----------------------------------------------------------------------------
562 -- Top-Level Declarations
563
564 topdecls :: { OrdList (LHsDecl RdrName) }
565         : topdecls ';' topdecl                  { $1 `appOL` $3 }
566         | topdecls ';'                          { $1 }
567         | topdecl                               { $1 }
568
569 topdecl :: { OrdList (LHsDecl RdrName) }
570         : cl_decl                               { unitOL (L1 (TyClD (unLoc $1))) }
571         | ty_decl                               { unitOL (L1 (TyClD (unLoc $1))) }
572         | 'instance' inst_type where_inst
573             { let (binds, sigs, ats, _) = cvBindsAndSigs (unLoc $3)
574               in 
575               unitOL (L (comb3 $1 $2 $3) (InstD (InstDecl $2 binds sigs ats)))}
576         | stand_alone_deriving                  { unitOL (LL (DerivD (unLoc $1))) }
577         | 'default' '(' comma_types0 ')'        { unitOL (LL $ DefD (DefaultDecl $3)) }
578         | 'foreign' fdecl                       { unitOL (LL (unLoc $2)) }
579         | '{-# DEPRECATED' deprecations '#-}'   { $2 }
580         | '{-# WARNING' warnings '#-}'          { $2 }
581         | '{-# RULES' rules '#-}'               { $2 }
582         | '{-# VECTORISE_SCALAR' qvar '#-}'     { unitOL $ LL $ VectD (HsVect       $2 Nothing) }
583         | '{-# VECTORISE' qvar '=' exp '#-}'    { unitOL $ LL $ VectD (HsVect       $2 (Just $4)) }
584         | '{-# NOVECTORISE' qvar '#-}'          { unitOL $ LL $ VectD (HsNoVect     $2) }
585         | '{-# VECTORISE' 'type' gtycon '#-}'     
586                                                 { unitOL $ LL $ 
587                                                     VectD (HsVectTypeIn False $3 Nothing) }
588         | '{-# VECTORISE_SCALAR' 'type' gtycon '#-}'     
589                                                 { unitOL $ LL $ 
590                                                     VectD (HsVectTypeIn True $3 Nothing) }
591         | '{-# VECTORISE' 'type' gtycon '=' gtycon '#-}'     
592                                                 { unitOL $ LL $ 
593                                                     VectD (HsVectTypeIn False $3 (Just $5)) }
594         | '{-# VECTORISE_SCALAR' 'type' gtycon '=' gtycon '#-}'     
595                                                 { unitOL $ LL $ 
596                                                     VectD (HsVectTypeIn True $3 (Just $5)) }
597         | '{-# VECTORISE' 'class' gtycon '#-}'  { unitOL $ LL $ VectD (HsVectClassIn $3) }
598         | '{-# VECTORISE_SCALAR' 'instance' type '#-}'     
599                                                 { unitOL $ LL $ VectD (HsVectInstIn $3) }
600         | annotation { unitOL $1 }
601         | decl                                  { unLoc $1 }
602
603         -- Template Haskell Extension
604         -- The $(..) form is one possible form of infixexp
605         -- but we treat an arbitrary expression just as if 
606         -- it had a $(..) wrapped around it
607         | infixexp                              { unitOL (LL $ mkTopSpliceDecl $1) } 
608
609 -- Type classes
610 --
611 cl_decl :: { LTyClDecl RdrName }
612         : 'class' tycl_hdr fds where_cls        {% mkClassDecl (comb4 $1 $2 $3 $4) $2 $3 $4 }
613
614 -- Type declarations (toplevel)
615 --
616 ty_decl :: { LTyClDecl RdrName }
617            -- ordinary type synonyms
618         : 'type' type '=' ctypedoc
619                 -- Note ctype, not sigtype, on the right of '='
620                 -- We allow an explicit for-all but we don't insert one
621                 -- in   type Foo a = (b,b)
622                 -- Instead we just say b is out of scope
623                 --
624                 -- Note the use of type for the head; this allows
625                 -- infix type constructors to be declared 
626                 {% mkTySynonym (comb2 $1 $4) False $2 $4 }
627
628            -- type family declarations
629         | 'type' 'family' type opt_kind_sig 
630                 -- Note the use of type for the head; this allows
631                 -- infix type constructors to be declared
632                 {% mkTyFamily (comb3 $1 $3 $4) TypeFamily $3 (unLoc $4) }
633
634            -- type instance declarations
635         | 'type' 'instance' type '=' ctype
636                 -- Note the use of type for the head; this allows
637                 -- infix type constructors and type patterns
638                 {% mkTySynonym (comb2 $1 $5) True $3 $5 }
639
640           -- ordinary data type or newtype declaration
641         | data_or_newtype tycl_hdr constrs deriving
642                 {% mkTyData (comb4 $1 $2 $3 $4) (unLoc $1) False $2 
643                             Nothing (reverse (unLoc $3)) (unLoc $4) }
644                                    -- We need the location on tycl_hdr in case 
645                                    -- constrs and deriving are both empty
646
647           -- ordinary GADT declaration
648         | data_or_newtype tycl_hdr opt_kind_sig 
649                  gadt_constrlist
650                  deriving
651                 {% mkTyData (comb4 $1 $2 $4 $5) (unLoc $1) False $2 
652                             (unLoc $3) (unLoc $4) (unLoc $5) }
653                                    -- We need the location on tycl_hdr in case 
654                                    -- constrs and deriving are both empty
655
656           -- data/newtype family
657         | 'data' 'family' type opt_kind_sig
658                 {% mkTyFamily (comb3 $1 $2 $4) DataFamily $3 (unLoc $4) }
659
660           -- data/newtype instance declaration
661         | data_or_newtype 'instance' tycl_hdr constrs deriving
662                 {% mkTyData (comb4 $1 $3 $4 $5) (unLoc $1) True $3
663                             Nothing (reverse (unLoc $4)) (unLoc $5) }
664
665           -- GADT instance declaration
666         | data_or_newtype 'instance' tycl_hdr opt_kind_sig 
667                  gadt_constrlist
668                  deriving
669                 {% mkTyData (comb4 $1 $3 $5 $6) (unLoc $1) True $3
670                             (unLoc $4) (unLoc $5) (unLoc $6) }
671
672 -- Associated type family declarations
673 --
674 -- * They have a different syntax than on the toplevel (no family special
675 --   identifier).
676 --
677 -- * They also need to be separate from instances; otherwise, data family
678 --   declarations without a kind signature cause parsing conflicts with empty
679 --   data declarations. 
680 --
681 at_decl_cls :: { LTyClDecl RdrName }
682            -- type family declarations
683         : 'type' type opt_kind_sig
684                 -- Note the use of type for the head; this allows
685                 -- infix type constructors to be declared
686                 {% mkTyFamily (comb3 $1 $2 $3) TypeFamily $2 (unLoc $3) }
687
688            -- default type instance
689         | 'type' type '=' ctype
690                 -- Note the use of type for the head; this allows
691                 -- infix type constructors and type patterns
692                 {% mkTySynonym (comb2 $1 $4) True $2 $4 }
693
694           -- data/newtype family declaration
695         | 'data' type opt_kind_sig
696                 {% mkTyFamily (comb3 $1 $2 $3) DataFamily $2 (unLoc $3) }
697
698 -- Associated type instances
699 --
700 at_decl_inst :: { LTyClDecl RdrName }
701            -- type instance declarations
702         : 'type' type '=' ctype
703                 -- Note the use of type for the head; this allows
704                 -- infix type constructors and type patterns
705                 {% mkTySynonym (comb2 $1 $4) True $2 $4 }
706
707         -- data/newtype instance declaration
708         | data_or_newtype tycl_hdr constrs deriving
709                 {% mkTyData (comb4 $1 $2 $3 $4) (unLoc $1) True $2 
710                             Nothing (reverse (unLoc $3)) (unLoc $4) }
711
712         -- GADT instance declaration
713         | data_or_newtype tycl_hdr opt_kind_sig 
714                  gadt_constrlist
715                  deriving
716                 {% mkTyData (comb4 $1 $2 $4 $5) (unLoc $1) True $2 
717                             (unLoc $3) (unLoc $4) (unLoc $5) }
718
719 data_or_newtype :: { Located NewOrData }
720         : 'data'        { L1 DataType }
721         | 'newtype'     { L1 NewType }
722
723 opt_kind_sig :: { Located (Maybe (LHsKind RdrName)) }
724         :                               { noLoc Nothing }
725         | '::' kind                     { LL (Just $2) }
726
727 -- tycl_hdr parses the header of a class or data type decl,
728 -- which takes the form
729 --      T a b
730 --      Eq a => T a
731 --      (Eq a, Ord b) => T a b
732 --      T Int [a]                       -- for associated types
733 -- Rather a lot of inlining here, else we get reduce/reduce errors
734 tycl_hdr :: { Located (Maybe (LHsContext RdrName), LHsType RdrName) }
735         : context '=>' type             { LL (Just $1, $3) }
736         | type                          { L1 (Nothing, $1) }
737
738 -----------------------------------------------------------------------------
739 -- Stand-alone deriving
740
741 -- Glasgow extension: stand-alone deriving declarations
742 stand_alone_deriving :: { LDerivDecl RdrName }
743         : 'deriving' 'instance' inst_type { LL (DerivDecl $3) }
744
745 -----------------------------------------------------------------------------
746 -- Nested declarations
747
748 -- Declaration in class bodies
749 --
750 decl_cls  :: { Located (OrdList (LHsDecl RdrName)) }
751 decl_cls  : at_decl_cls                 { LL (unitOL (L1 (TyClD (unLoc $1)))) }
752           | decl                        { $1 }
753
754           -- A 'default' signature used with the generic-programming extension
755           | 'default' infixexp '::' sigtypedoc
756                     {% do { (TypeSig l ty) <- checkValSig $2 $4
757                           ; return (LL $ unitOL (LL $ SigD (GenericSig l ty))) } }
758
759 decls_cls :: { Located (OrdList (LHsDecl RdrName)) }    -- Reversed
760           : decls_cls ';' decl_cls      { LL (unLoc $1 `appOL` unLoc $3) }
761           | decls_cls ';'               { LL (unLoc $1) }
762           | decl_cls                    { $1 }
763           | {- empty -}                 { noLoc nilOL }
764
765
766 decllist_cls
767         :: { Located (OrdList (LHsDecl RdrName)) }      -- Reversed
768         : '{'         decls_cls '}'     { LL (unLoc $2) }
769         |     vocurly decls_cls close   { $2 }
770
771 -- Class body
772 --
773 where_cls :: { Located (OrdList (LHsDecl RdrName)) }    -- Reversed
774                                 -- No implicit parameters
775                                 -- May have type declarations
776         : 'where' decllist_cls          { LL (unLoc $2) }
777         | {- empty -}                   { noLoc nilOL }
778
779 -- Declarations in instance bodies
780 --
781 decl_inst  :: { Located (OrdList (LHsDecl RdrName)) }
782 decl_inst  : at_decl_inst               { LL (unitOL (L1 (TyClD (unLoc $1)))) }
783            | decl                       { $1 }
784
785 decls_inst :: { Located (OrdList (LHsDecl RdrName)) }   -- Reversed
786            : decls_inst ';' decl_inst   { LL (unLoc $1 `appOL` unLoc $3) }
787            | decls_inst ';'             { LL (unLoc $1) }
788            | decl_inst                  { $1 }
789            | {- empty -}                { noLoc nilOL }
790
791 decllist_inst 
792         :: { Located (OrdList (LHsDecl RdrName)) }      -- Reversed
793         : '{'         decls_inst '}'    { LL (unLoc $2) }
794         |     vocurly decls_inst close  { $2 }
795
796 -- Instance body
797 --
798 where_inst :: { Located (OrdList (LHsDecl RdrName)) }   -- Reversed
799                                 -- No implicit parameters
800                                 -- May have type declarations
801         : 'where' decllist_inst         { LL (unLoc $2) }
802         | {- empty -}                   { noLoc nilOL }
803
804 -- Declarations in binding groups other than classes and instances
805 --
806 decls   :: { Located (OrdList (LHsDecl RdrName)) }      
807         : decls ';' decl                { let { this = unLoc $3;
808                                     rest = unLoc $1;
809                                     these = rest `appOL` this }
810                               in rest `seq` this `seq` these `seq`
811                                     LL these }
812         | decls ';'                     { LL (unLoc $1) }
813         | decl                          { $1 }
814         | {- empty -}                   { noLoc nilOL }
815
816 decllist :: { Located (OrdList (LHsDecl RdrName)) }
817         : '{'            decls '}'      { LL (unLoc $2) }
818         |     vocurly    decls close    { $2 }
819
820 -- Binding groups other than those of class and instance declarations
821 --
822 binds   ::  { Located (HsLocalBinds RdrName) }          -- May have implicit parameters
823                                                 -- No type declarations
824         : decllist                      { L1 (HsValBinds (cvBindGroup (unLoc $1))) }
825         | '{'            dbinds '}'     { LL (HsIPBinds (IPBinds (unLoc $2) emptyTcEvBinds)) }
826         |     vocurly    dbinds close   { L (getLoc $2) (HsIPBinds (IPBinds (unLoc $2) emptyTcEvBinds)) }
827
828 wherebinds :: { Located (HsLocalBinds RdrName) }        -- May have implicit parameters
829                                                 -- No type declarations
830         : 'where' binds                 { LL (unLoc $2) }
831         | {- empty -}                   { noLoc emptyLocalBinds }
832
833
834 -----------------------------------------------------------------------------
835 -- Transformation Rules
836
837 rules   :: { OrdList (LHsDecl RdrName) }
838         :  rules ';' rule                       { $1 `snocOL` $3 }
839         |  rules ';'                            { $1 }
840         |  rule                                 { unitOL $1 }
841         |  {- empty -}                          { nilOL }
842
843 rule    :: { LHsDecl RdrName }
844         : STRING activation rule_forall infixexp '=' exp
845              { LL $ RuleD (HsRule (getSTRING $1) 
846                                   ($2 `orElse` AlwaysActive) 
847                                   $3 $4 placeHolderNames $6 placeHolderNames) }
848
849 activation :: { Maybe Activation } 
850         : {- empty -}                           { Nothing }
851         | explicit_activation                   { Just $1 }
852
853 explicit_activation :: { Activation }  -- In brackets
854         : '[' INTEGER ']'               { ActiveAfter  (fromInteger (getINTEGER $2)) }
855         | '[' '~' INTEGER ']'           { ActiveBefore (fromInteger (getINTEGER $3)) }
856
857 rule_forall :: { [RuleBndr RdrName] }
858         : 'forall' rule_var_list '.'            { $2 }
859         | {- empty -}                           { [] }
860
861 rule_var_list :: { [RuleBndr RdrName] }
862         : rule_var                              { [$1] }
863         | rule_var rule_var_list                { $1 : $2 }
864
865 rule_var :: { RuleBndr RdrName }
866         : varid                                 { RuleBndr $1 }
867         | '(' varid '::' ctype ')'              { RuleBndrSig $2 $4 }
868
869 -----------------------------------------------------------------------------
870 -- Warnings and deprecations (c.f. rules)
871
872 warnings :: { OrdList (LHsDecl RdrName) }
873         : warnings ';' warning          { $1 `appOL` $3 }
874         | warnings ';'                  { $1 }
875         | warning                               { $1 }
876         | {- empty -}                           { nilOL }
877
878 -- SUP: TEMPORARY HACK, not checking for `module Foo'
879 warning :: { OrdList (LHsDecl RdrName) }
880         : namelist strings
881                 { toOL [ LL $ WarningD (Warning n (WarningTxt $ unLoc $2))
882                        | n <- unLoc $1 ] }
883
884 deprecations :: { OrdList (LHsDecl RdrName) }
885         : deprecations ';' deprecation          { $1 `appOL` $3 }
886         | deprecations ';'                      { $1 }
887         | deprecation                           { $1 }
888         | {- empty -}                           { nilOL }
889
890 -- SUP: TEMPORARY HACK, not checking for `module Foo'
891 deprecation :: { OrdList (LHsDecl RdrName) }
892         : namelist strings
893                 { toOL [ LL $ WarningD (Warning n (DeprecatedTxt $ unLoc $2))
894                        | n <- unLoc $1 ] }
895
896 strings :: { Located [FastString] }
897     : STRING { L1 [getSTRING $1] }
898     | '[' stringlist ']' { LL $ fromOL (unLoc $2) }
899
900 stringlist :: { Located (OrdList FastString) }
901     : stringlist ',' STRING { LL (unLoc $1 `snocOL` getSTRING $3) }
902     | STRING                { LL (unitOL (getSTRING $1)) }
903
904 -----------------------------------------------------------------------------
905 -- Annotations
906 annotation :: { LHsDecl RdrName }
907     : '{-# ANN' name_var aexp '#-}'      { LL (AnnD $ HsAnnotation (ValueAnnProvenance (unLoc $2)) $3) }
908     | '{-# ANN' 'type' tycon aexp '#-}'  { LL (AnnD $ HsAnnotation (TypeAnnProvenance (unLoc $3)) $4) }
909     | '{-# ANN' 'module' aexp '#-}'      { LL (AnnD $ HsAnnotation ModuleAnnProvenance $3) }
910
911
912 -----------------------------------------------------------------------------
913 -- Foreign import and export declarations
914
915 fdecl :: { LHsDecl RdrName }
916 fdecl : 'import' callconv safety fspec
917                 {% mkImport $2 $3 (unLoc $4) >>= return.LL }
918       | 'import' callconv        fspec          
919                 {% do { d <- mkImport $2 PlaySafe (unLoc $3);
920                         return (LL d) } }
921       | 'export' callconv fspec
922                 {% mkExport $2 (unLoc $3) >>= return.LL }
923
924 callconv :: { CCallConv }
925           : 'stdcall'                   { StdCallConv }
926           | 'ccall'                     { CCallConv   }
927           | 'capi'                      { CApiConv    }
928           | 'prim'                      { PrimCallConv}
929
930 safety :: { Safety }
931         : 'unsafe'                      { PlayRisky }
932         | 'safe'                        { PlaySafe }
933         | 'interruptible'               { PlayInterruptible }
934
935 fspec :: { Located (Located FastString, Located RdrName, LHsType RdrName) }
936        : STRING var '::' sigtypedoc     { LL (L (getLoc $1) (getSTRING $1), $2, $4) }
937        |        var '::' sigtypedoc     { LL (noLoc nilFS, $1, $3) }
938          -- if the entity string is missing, it defaults to the empty string;
939          -- the meaning of an empty entity string depends on the calling
940          -- convention
941
942 -----------------------------------------------------------------------------
943 -- Type signatures
944
945 opt_sig :: { Maybe (LHsType RdrName) }
946         : {- empty -}                   { Nothing }
947         | '::' sigtype                  { Just $2 }
948
949 opt_asig :: { Maybe (LHsType RdrName) }
950         : {- empty -}                   { Nothing }
951         | '::' atype                    { Just $2 }
952
953 sigtype :: { LHsType RdrName }          -- Always a HsForAllTy,
954                                         -- to tell the renamer where to generalise
955         : ctype                         { L1 (mkImplicitHsForAllTy (noLoc []) $1) }
956         -- Wrap an Implicit forall if there isn't one there already
957
958 sigtypedoc :: { LHsType RdrName }       -- Always a HsForAllTy
959         : ctypedoc                      { L1 (mkImplicitHsForAllTy (noLoc []) $1) }
960         -- Wrap an Implicit forall if there isn't one there already
961
962 sig_vars :: { Located [Located RdrName] }
963          : sig_vars ',' var             { LL ($3 : unLoc $1) }
964          | var                          { L1 [$1] }
965
966 sigtypes1 :: { [LHsType RdrName] }      -- Always HsForAllTys
967         : sigtype                       { [ $1 ] }
968         | sigtype ',' sigtypes1         { $1 : $3 }
969
970 -----------------------------------------------------------------------------
971 -- Types
972
973 infixtype :: { LHsType RdrName }
974         : btype qtyconop type         { LL $ mkHsOpTy $1 $2 $3 }
975         | btype tyvarop  type    { LL $ mkHsOpTy $1 $2 $3 }
976
977 strict_mark :: { Located HsBang }
978         : '!'                           { L1 HsStrict }
979         | '{-# UNPACK' '#-}' '!'        { LL HsUnpack }
980         | '{-# NOUNPACK' '#-}' '!'      { LL HsNoUnpack }
981
982 -- A ctype is a for-all type
983 ctype   :: { LHsType RdrName }
984         : 'forall' tv_bndrs '.' ctype   { LL $ mkExplicitHsForAllTy $2 (noLoc []) $4 }
985         | context '=>' ctype            { LL $ mkImplicitHsForAllTy   $1 $3 }
986         -- A type of form (context => type) is an *implicit* HsForAllTy
987         | ipvar '::' type               { LL (HsIParamTy (unLoc $1) $3) }
988         | type                          { $1 }
989
990 ----------------------
991 -- Notes for 'ctypedoc'
992 -- It would have been nice to simplify the grammar by unifying `ctype` and 
993 -- ctypedoc` into one production, allowing comments on types everywhere (and
994 -- rejecting them after parsing, where necessary).  This is however not possible
995 -- since it leads to ambiguity. The reason is the support for comments on record
996 -- fields: 
997 --         data R = R { field :: Int -- ^ comment on the field }
998 -- If we allow comments on types here, it's not clear if the comment applies
999 -- to 'field' or to 'Int'. So we must use `ctype` to describe the type.
1000
1001 ctypedoc :: { LHsType RdrName }
1002         : 'forall' tv_bndrs '.' ctypedoc        { LL $ mkExplicitHsForAllTy $2 (noLoc []) $4 }
1003         | context '=>' ctypedoc         { LL $ mkImplicitHsForAllTy   $1 $3 }
1004         -- A type of form (context => type) is an *implicit* HsForAllTy
1005         | ipvar '::' type               { LL (HsIParamTy (unLoc $1) $3) }
1006         | typedoc                       { $1 }
1007
1008 ----------------------
1009 -- Notes for 'context'
1010 -- We parse a context as a btype so that we don't get reduce/reduce
1011 -- errors in ctype.  The basic problem is that
1012 --      (Eq a, Ord a)
1013 -- looks so much like a tuple type.  We can't tell until we find the =>
1014
1015 -- We have the t1 ~ t2 form both in 'context' and in type, 
1016 -- to permit an individual equational constraint without parenthesis.
1017 -- Thus for some reason we allow    f :: a~b => blah
1018 -- but not                          f :: ?x::Int => blah
1019 context :: { LHsContext RdrName }
1020         : btype '~'      btype          {% checkContext
1021                                              (LL $ HsEqTy $1 $3) }
1022         | btype                         {% checkContext $1 }
1023
1024 type :: { LHsType RdrName }
1025         : btype                         { $1 }
1026         | btype qtyconop type           { LL $ mkHsOpTy $1 $2 $3 }
1027         | btype tyvarop  type           { LL $ mkHsOpTy $1 $2 $3 }
1028         | btype '->'     ctype          { LL $ HsFunTy $1 $3 }
1029         | btype '~'      btype          { LL $ HsEqTy $1 $3 }
1030                                         -- see Note [Promotion]
1031         | btype SIMPLEQUOTE qconop type     { LL $ mkHsOpTy $1 $3 $4 }
1032         | btype SIMPLEQUOTE varop  type     { LL $ mkHsOpTy $1 $3 $4 }
1033
1034 typedoc :: { LHsType RdrName }
1035         : btype                          { $1 }
1036         | btype docprev                  { LL $ HsDocTy $1 $2 }
1037         | btype qtyconop type            { LL $ mkHsOpTy $1 $2 $3 }
1038         | btype qtyconop type docprev    { LL $ HsDocTy (L (comb3 $1 $2 $3) (mkHsOpTy $1 $2 $3)) $4 }
1039         | btype tyvarop  type            { LL $ mkHsOpTy $1 $2 $3 }
1040         | btype tyvarop  type docprev    { LL $ HsDocTy (L (comb3 $1 $2 $3) (mkHsOpTy $1 $2 $3)) $4 }
1041         | btype '->'     ctypedoc        { LL $ HsFunTy $1 $3 }
1042         | btype docprev '->' ctypedoc    { LL $ HsFunTy (L (comb2 $1 $2) (HsDocTy $1 $2)) $4 }
1043         | btype '~'      btype           { LL $ HsEqTy $1 $3 }
1044
1045 btype :: { LHsType RdrName }
1046         : btype atype                   { LL $ HsAppTy $1 $2 }
1047         | atype                         { $1 }
1048
1049 atype :: { LHsType RdrName }
1050         : ntgtycon                       { L1 (HsTyVar (unLoc $1)) }      -- Not including unit tuples
1051         | tyvar                          { L1 (HsTyVar (unLoc $1)) }      -- (See Note [Unit tuples])
1052         | strict_mark atype              { LL (HsBangTy (unLoc $1) $2) }  -- Constructor sigs only
1053         | '{' fielddecls '}'             {% checkRecordSyntax (LL $ HsRecTy $2) } -- Constructor sigs only
1054         | '(' ')'                        { LL $ HsTupleTy HsBoxedOrConstraintTuple []      }
1055         | '(' ctype ',' comma_types1 ')' { LL $ HsTupleTy HsBoxedOrConstraintTuple ($2:$4) }
1056         | '(#' '#)'                      { LL $ HsTupleTy HsUnboxedTuple           []      }       
1057         | '(#' comma_types1 '#)'         { LL $ HsTupleTy HsUnboxedTuple           $2      }
1058         | '[' ctype ']'                  { LL $ HsListTy  $2 }
1059         | '[:' ctype ':]'                { LL $ HsPArrTy  $2 }
1060         | '(' ctype ')'                  { LL $ HsParTy   $2 }
1061         | '(' ctype '::' kind ')'        { LL $ HsKindSig $2 $4 }
1062         | quasiquote                     { L1 (HsQuasiQuoteTy (unLoc $1)) }
1063         | '$(' exp ')'                   { LL $ mkHsSpliceTy $2 }
1064         | TH_ID_SPLICE                   { LL $ mkHsSpliceTy $ L1 $ HsVar $
1065                                            mkUnqual varName (getTH_ID_SPLICE $1) }
1066                                                       -- see Note [Promotion] for the followings
1067         | SIMPLEQUOTE qconid                          { LL $ HsTyVar $ unLoc $2 }
1068         | SIMPLEQUOTE  '(' ')'                        { LL $ HsTyVar $ getRdrName unitDataCon }
1069         | SIMPLEQUOTE  '(' ctype ',' comma_types1 ')' { LL $ HsExplicitTupleTy [] ($3 : $5) }
1070         | SIMPLEQUOTE  '[' comma_types0 ']'           { LL $ HsExplicitListTy placeHolderKind $3 }
1071         | '[' ctype ',' comma_types1 ']'              { LL $ HsExplicitListTy placeHolderKind ($2 : $4) }
1072
1073 -- An inst_type is what occurs in the head of an instance decl
1074 --      e.g.  (Foo a, Gaz b) => Wibble a b
1075 -- It's kept as a single type, with a MonoDictTy at the right
1076 -- hand corner, for convenience.
1077 inst_type :: { LHsType RdrName }
1078         : sigtype                       { $1 }
1079
1080 inst_types1 :: { [LHsType RdrName] }
1081         : inst_type                     { [$1] }
1082         | inst_type ',' inst_types1     { $1 : $3 }
1083
1084 comma_types0  :: { [LHsType RdrName] }
1085         : comma_types1                  { $1 }
1086         | {- empty -}                   { [] }
1087
1088 comma_types1    :: { [LHsType RdrName] }
1089         : ctype                         { [$1] }
1090         | ctype  ',' comma_types1       { $1 : $3 }
1091
1092 tv_bndrs :: { [LHsTyVarBndr RdrName] }
1093          : tv_bndr tv_bndrs             { $1 : $2 }
1094          | {- empty -}                  { [] }
1095
1096 tv_bndr :: { LHsTyVarBndr RdrName }
1097         : tyvar                         { L1 (UserTyVar (unLoc $1) placeHolderKind) }
1098         | '(' tyvar '::' kind ')'       { LL (KindedTyVar (unLoc $2) $4 placeHolderKind) }
1099
1100 fds :: { Located [Located (FunDep RdrName)] }
1101         : {- empty -}                   { noLoc [] }
1102         | '|' fds1                      { LL (reverse (unLoc $2)) }
1103
1104 fds1 :: { Located [Located (FunDep RdrName)] }
1105         : fds1 ',' fd                   { LL ($3 : unLoc $1) }
1106         | fd                            { L1 [$1] }
1107
1108 fd :: { Located (FunDep RdrName) }
1109         : varids0 '->' varids0          { L (comb3 $1 $2 $3)
1110                                            (reverse (unLoc $1), reverse (unLoc $3)) }
1111
1112 varids0 :: { Located [RdrName] }
1113         : {- empty -}                   { noLoc [] }
1114         | varids0 tyvar                 { LL (unLoc $2 : unLoc $1) }
1115
1116 -----------------------------------------------------------------------------
1117 -- Kinds
1118
1119 kind :: { LHsKind RdrName }
1120         : bkind                  { $1 }
1121         | bkind '->' kind        { LL $ HsFunTy $1 $3 }
1122
1123 bkind :: { LHsKind RdrName }
1124         : akind                  { $1 }
1125         | bkind akind            { LL $ HsAppTy $1 $2 }
1126
1127 akind :: { LHsKind RdrName }
1128         : '*'                    { L1 $ HsTyVar (nameRdrName liftedTypeKindTyConName) }
1129         | '(' kind ')'           { LL $ HsParTy $2 }
1130         | pkind                  { $1 }
1131
1132 pkind :: { LHsKind RdrName }  -- promoted type, see Note [Promotion]
1133         : qtycon                          { L1 $ HsTyVar $ unLoc $1 }
1134         | '(' ')'                         { LL $ HsTyVar $ getRdrName unitTyCon }
1135         | '(' kind ',' comma_kinds1 ')'   { LL $ HsTupleTy HsBoxedTuple ($2 : $4) }
1136         | '[' kind ']'                    { LL $ HsListTy $2 }
1137
1138 comma_kinds1 :: { [LHsKind RdrName] }
1139         : kind                          { [$1] }
1140         | kind  ',' comma_kinds1        { $1 : $3 }
1141
1142 {- Note [Promotion]
1143    ~~~~~~~~~~~~~~~~
1144
1145 - Syntax of promoted qualified names
1146 We write 'Nat.Zero instead of Nat.'Zero when dealing with qualified
1147 names. Moreover ticks are only allowed in types, not in kinds, for a
1148 few reasons:
1149   1. we don't need quotes since we cannot define names in kinds
1150   2. if one day we merge types and kinds, tick would mean look in DataName
1151   3. we don't have a kind namespace anyway
1152
1153 - Syntax of explicit kind polymorphism  (IA0_TODO: not yet implemented)
1154 Kind abstraction is implicit. We write
1155 > data SList (s :: k -> *) (as :: [k]) where ...
1156 because it looks like what we do in terms
1157 > id (x :: a) = x
1158
1159 - Name resolution
1160 When the user write Zero instead of 'Zero in types, we parse it a
1161 HsTyVar ("Zero", TcClsName) instead of HsTyVar ("Zero", DataName). We
1162 deal with this in the renamer. If a HsTyVar ("Zero", TcClsName) is not
1163 bounded in the type level, then we look for it in the term level (we
1164 change its namespace to DataName, see Note [Demotion] in OccName). And
1165 both become a HsTyVar ("Zero", DataName) after the renamer.
1166
1167 -}
1168
1169
1170 -----------------------------------------------------------------------------
1171 -- Datatype declarations
1172
1173 gadt_constrlist :: { Located [LConDecl RdrName] }       -- Returned in order
1174         : 'where' '{'        gadt_constrs '}'      { L (comb2 $1 $3) (unLoc $3) }
1175         | 'where' vocurly    gadt_constrs close    { L (comb2 $1 $3) (unLoc $3) }
1176         | {- empty -}                              { noLoc [] }
1177
1178 gadt_constrs :: { Located [LConDecl RdrName] }
1179         : gadt_constr ';' gadt_constrs  { L (comb2 (head $1) $3) ($1 ++ unLoc $3) }
1180         | gadt_constr                   { L (getLoc (head $1)) $1 }
1181         | {- empty -}                   { noLoc [] }
1182
1183 -- We allow the following forms:
1184 --      C :: Eq a => a -> T a
1185 --      C :: forall a. Eq a => !a -> T a
1186 --      D { x,y :: a } :: T a
1187 --      forall a. Eq a => D { x,y :: a } :: T a
1188
1189 gadt_constr :: { [LConDecl RdrName] }   -- Returns a list because of:   C,D :: ty
1190         : con_list '::' sigtype
1191                 { map (sL (comb2 $1 $3)) (mkGadtDecl (unLoc $1) $3) } 
1192
1193                 -- Deprecated syntax for GADT record declarations
1194         | oqtycon '{' fielddecls '}' '::' sigtype
1195                 {% do { cd <- mkDeprecatedGadtRecordDecl (comb2 $1 $6) $1 $3 $6
1196                       ; cd' <- checkRecordSyntax cd
1197                       ; return [cd'] } }
1198
1199 constrs :: { Located [LConDecl RdrName] }
1200         : maybe_docnext '=' constrs1    { L (comb2 $2 $3) (addConDocs (unLoc $3) $1) }
1201
1202 constrs1 :: { Located [LConDecl RdrName] }
1203         : constrs1 maybe_docnext '|' maybe_docprev constr { LL (addConDoc $5 $2 : addConDocFirst (unLoc $1) $4) }
1204         | constr                                          { L1 [$1] }
1205
1206 constr :: { LConDecl RdrName }
1207         : maybe_docnext forall context '=>' constr_stuff maybe_docprev  
1208                 { let (con,details) = unLoc $5 in 
1209                   addConDoc (L (comb4 $2 $3 $4 $5) (mkSimpleConDecl con (unLoc $2) $3 details))
1210                             ($1 `mplus` $6) }
1211         | maybe_docnext forall constr_stuff maybe_docprev
1212                 { let (con,details) = unLoc $3 in 
1213                   addConDoc (L (comb2 $2 $3) (mkSimpleConDecl con (unLoc $2) (noLoc []) details))
1214                             ($1 `mplus` $4) }
1215
1216 forall :: { Located [LHsTyVarBndr RdrName] }
1217         : 'forall' tv_bndrs '.'         { LL $2 }
1218         | {- empty -}                   { noLoc [] }
1219
1220 constr_stuff :: { Located (Located RdrName, HsConDeclDetails RdrName) }
1221 -- We parse the constructor declaration 
1222 --      C t1 t2
1223 -- as a btype (treating C as a type constructor) and then convert C to be
1224 -- a data constructor.  Reason: it might continue like this:
1225 --      C t1 t2 %: D Int
1226 -- in which case C really would be a type constructor.  We can't resolve this
1227 -- ambiguity till we come across the constructor oprerator :% (or not, more usually)
1228         : btype                         {% splitCon $1 >>= return.LL }
1229         | btype conop btype             {  LL ($2, InfixCon $1 $3) }
1230
1231 fielddecls :: { [ConDeclField RdrName] }
1232         : {- empty -}     { [] }
1233         | fielddecls1     { $1 }
1234
1235 fielddecls1 :: { [ConDeclField RdrName] }
1236         : fielddecl maybe_docnext ',' maybe_docprev fielddecls1
1237                       { [ addFieldDoc f $4 | f <- $1 ] ++ addFieldDocs $5 $2 }
1238                              -- This adds the doc $4 to each field separately
1239         | fielddecl   { $1 }
1240
1241 fielddecl :: { [ConDeclField RdrName] }    -- A list because of   f,g :: Int
1242         : maybe_docnext sig_vars '::' ctype maybe_docprev      { [ ConDeclField fld $4 ($1 `mplus` $5) 
1243                                                                  | fld <- reverse (unLoc $2) ] }
1244
1245 -- We allow the odd-looking 'inst_type' in a deriving clause, so that
1246 -- we can do deriving( forall a. C [a] ) in a newtype (GHC extension).
1247 -- The 'C [a]' part is converted to an HsPredTy by checkInstType
1248 -- We don't allow a context, but that's sorted out by the type checker.
1249 deriving :: { Located (Maybe [LHsType RdrName]) }
1250         : {- empty -}                           { noLoc Nothing }
1251         | 'deriving' qtycon                     { let { L loc tv = $2 }
1252                                                   in LL (Just [L loc (HsTyVar tv)]) } 
1253         | 'deriving' '(' ')'                    { LL (Just []) }
1254         | 'deriving' '(' inst_types1 ')'        { LL (Just $3) }
1255              -- Glasgow extension: allow partial 
1256              -- applications in derivings
1257
1258 -----------------------------------------------------------------------------
1259 -- Value definitions
1260
1261 {- Note [Declaration/signature overlap]
1262 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1263 There's an awkward overlap with a type signature.  Consider
1264         f :: Int -> Int = ...rhs...
1265    Then we can't tell whether it's a type signature or a value
1266    definition with a result signature until we see the '='.
1267    So we have to inline enough to postpone reductions until we know.
1268 -}
1269
1270 {-
1271   ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var
1272   instead of qvar, we get another shift/reduce-conflict. Consider the
1273   following programs:
1274   
1275      { (^^) :: Int->Int ; }          Type signature; only var allowed
1276
1277      { (^^) :: Int->Int = ... ; }    Value defn with result signature;
1278                                      qvar allowed (because of instance decls)
1279   
1280   We can't tell whether to reduce var to qvar until after we've read the signatures.
1281 -}
1282
1283 docdecl :: { LHsDecl RdrName }
1284         : docdecld { L1 (DocD (unLoc $1)) }
1285
1286 docdecld :: { LDocDecl }
1287         : docnext                               { L1 (DocCommentNext (unLoc $1)) }
1288         | docprev                               { L1 (DocCommentPrev (unLoc $1)) }
1289         | docnamed                              { L1 (case (unLoc $1) of (n, doc) -> DocCommentNamed n doc) }
1290         | docsection                            { L1 (case (unLoc $1) of (n, doc) -> DocGroup n doc) }
1291
1292 decl    :: { Located (OrdList (LHsDecl RdrName)) }
1293         : sigdecl               { $1 }
1294
1295         | '!' aexp rhs          {% do { let { e = LL (SectionR (LL (HsVar bang_RDR)) $2) };
1296                                         pat <- checkPattern e;
1297                                         return $ LL $ unitOL $ LL $ ValD $
1298                                                PatBind pat (unLoc $3)
1299                                                        placeHolderType placeHolderNames (Nothing,[]) } }
1300                                 -- Turn it all into an expression so that
1301                                 -- checkPattern can check that bangs are enabled
1302
1303         | infixexp opt_sig rhs  {% do { r <- checkValDef $1 $2 $3;
1304                                         let { l = comb2 $1 $> };
1305                                         return $! (sL l (unitOL $! (sL l $ ValD r))) } }
1306         | docdecl               { LL $ unitOL $1 }
1307
1308 rhs     :: { Located (GRHSs RdrName) }
1309         : '=' exp wherebinds    { sL (comb3 $1 $2 $3) $ GRHSs (unguardedRHS $2) (unLoc $3) }
1310         | gdrhs wherebinds      { LL $ GRHSs (reverse (unLoc $1)) (unLoc $2) }
1311
1312 gdrhs :: { Located [LGRHS RdrName] }
1313         : gdrhs gdrh            { LL ($2 : unLoc $1) }
1314         | gdrh                  { L1 [$1] }
1315
1316 gdrh :: { LGRHS RdrName }
1317         : '|' guardquals '=' exp        { sL (comb2 $1 $>) $ GRHS (unLoc $2) $4 }
1318
1319 sigdecl :: { Located (OrdList (LHsDecl RdrName)) }
1320         : 
1321         -- See Note [Declaration/signature overlap] for why we need infixexp here
1322           infixexp '::' sigtypedoc
1323                         {% do s <- checkValSig $1 $3 
1324                         ; return (LL $ unitOL (LL $ SigD s)) }
1325         | var ',' sig_vars '::' sigtypedoc
1326                                 { LL $ toOL [ LL $ SigD (TypeSig ($1 : unLoc $3) $5) ] }
1327         | infix prec ops        { LL $ toOL [ LL $ SigD (FixSig (FixitySig n (Fixity $2 (unLoc $1))))
1328                                              | n <- unLoc $3 ] }
1329         | '{-# INLINE' activation qvar '#-}'        
1330                 { LL $ unitOL (LL $ SigD (InlineSig $3 (mkInlinePragma (getINLINE $1) $2))) }
1331         | '{-# SPECIALISE' activation qvar '::' sigtypes1 '#-}'
1332                 { let inl_prag = mkInlinePragma (EmptyInlineSpec, FunLike) $2
1333                   in LL $ toOL [ LL $ SigD (SpecSig $3 t inl_prag) 
1334                                | t <- $5] }
1335         | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes1 '#-}'
1336                 { LL $ toOL [ LL $ SigD (SpecSig $3 t (mkInlinePragma (getSPEC_INLINE $1) $2))
1337                             | t <- $5] }
1338         | '{-# SPECIALISE' 'instance' inst_type '#-}'
1339                 { LL $ unitOL (LL $ SigD (SpecInstSig $3)) }
1340
1341 -----------------------------------------------------------------------------
1342 -- Expressions
1343
1344 quasiquote :: { Located (HsQuasiQuote RdrName) }
1345         : TH_QUASIQUOTE   { let { loc = getLoc $1
1346                                 ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc $1
1347                                 ; quoterId = mkUnqual varName quoter }
1348                             in L1 (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote) }
1349
1350 exp   :: { LHsExpr RdrName }
1351         : infixexp '::' sigtype         { LL $ ExprWithTySig $1 $3 }
1352         | infixexp '-<' exp             { LL $ HsArrApp $1 $3 placeHolderType HsFirstOrderApp True }
1353         | infixexp '>-' exp             { LL $ HsArrApp $3 $1 placeHolderType HsFirstOrderApp False }
1354         | infixexp '-<<' exp            { LL $ HsArrApp $1 $3 placeHolderType HsHigherOrderApp True }
1355         | infixexp '>>-' exp            { LL $ HsArrApp $3 $1 placeHolderType HsHigherOrderApp False}
1356         | infixexp                      { $1 }
1357
1358 infixexp :: { LHsExpr RdrName }
1359         : exp10                         { $1 }
1360         | infixexp qop exp10            { LL (OpApp $1 $2 (panic "fixity") $3) }
1361
1362 exp10 :: { LHsExpr RdrName }
1363         : '\\' apat apats opt_asig '->' exp     
1364                         { LL $ HsLam (mkMatchGroup [LL $ Match ($2:$3) $4
1365                                                                 (unguardedGRHSs $6)
1366                                                             ]) }
1367         | 'let' binds 'in' exp                  { LL $ HsLet (unLoc $2) $4 }
1368         | 'if' exp optSemi 'then' exp optSemi 'else' exp
1369                                         {% checkDoAndIfThenElse $2 $3 $5 $6 $8 >>
1370                                            return (LL $ mkHsIf $2 $5 $8) }
1371         | 'case' exp 'of' altslist              { LL $ HsCase $2 (mkMatchGroup (unLoc $4)) }
1372         | '-' fexp                              { LL $ NegApp $2 noSyntaxExpr }
1373
1374         | 'do' stmtlist                 { L (comb2 $1 $2) (mkHsDo DoExpr  (unLoc $2)) }
1375         | 'mdo' stmtlist                { L (comb2 $1 $2) (mkHsDo MDoExpr (unLoc $2)) }
1376
1377         | scc_annot exp                         { LL $ if opt_SccProfilingOn
1378                                                         then HsSCC (unLoc $1) $2
1379                                                         else HsPar $2 }
1380         | hpc_annot exp                         { LL $ if opt_Hpc
1381                                                         then HsTickPragma (unLoc $1) $2
1382                                                         else HsPar $2 }
1383
1384         | 'proc' aexp '->' exp  
1385                         {% checkPattern $2 >>= \ p -> 
1386                            return (LL $ HsProc p (LL $ HsCmdTop $4 [] 
1387                                                    placeHolderType undefined)) }
1388                                                 -- TODO: is LL right here?
1389
1390         | '{-# CORE' STRING '#-}' exp           { LL $ HsCoreAnn (getSTRING $2) $4 }
1391                                                     -- hdaume: core annotation
1392         | fexp                                  { $1 }
1393
1394 optSemi :: { Bool }
1395         : ';'         { True }
1396         | {- empty -} { False }
1397
1398 scc_annot :: { Located FastString }
1399         : '_scc_' STRING                        {% (addWarning Opt_WarnWarningsDeprecations (getLoc $1) (text "_scc_ is deprecated; use an SCC pragma instead")) >>= \_ ->
1400                                    ( do scc <- getSCC $2; return $ LL scc ) }
1401         | '{-# SCC' STRING '#-}'                {% do scc <- getSCC $2; return $ LL scc }
1402         | '{-# SCC' VARID  '#-}'                { LL (getVARID $2) }
1403
1404 hpc_annot :: { Located (FastString,(Int,Int),(Int,Int)) }
1405         : '{-# GENERATED' STRING INTEGER ':' INTEGER '-' INTEGER ':' INTEGER '#-}'
1406                                                 { LL $ (getSTRING $2
1407                                                        ,( fromInteger $ getINTEGER $3
1408                                                         , fromInteger $ getINTEGER $5
1409                                                         )
1410                                                        ,( fromInteger $ getINTEGER $7
1411                                                         , fromInteger $ getINTEGER $9
1412                                                         )
1413                                                        )
1414                                                  }
1415
1416 fexp    :: { LHsExpr RdrName }
1417         : fexp aexp                             { LL $ HsApp $1 $2 }
1418         | aexp                                  { $1 }
1419
1420 aexp    :: { LHsExpr RdrName }
1421         : qvar '@' aexp                 { LL $ EAsPat $1 $3 }
1422         | '~' aexp                      { LL $ ELazyPat $2 }
1423         | aexp1                 { $1 }
1424
1425 aexp1   :: { LHsExpr RdrName }
1426         : aexp1 '{' fbinds '}'  {% do { r <- mkRecConstrOrUpdate $1 (comb2 $2 $4) $3
1427                                       ; checkRecordSyntax (LL r) }}
1428         | aexp2                 { $1 }
1429
1430 -- Here was the syntax for type applications that I was planning
1431 -- but there are difficulties (e.g. what order for type args)
1432 -- so it's not enabled yet.
1433 -- But this case *is* used for the left hand side of a generic definition,
1434 -- which is parsed as an expression before being munged into a pattern
1435         | qcname '{|' type '|}'         { LL $ HsApp (sL (getLoc $1) (HsVar (unLoc $1)))
1436                                                      (sL (getLoc $3) (HsType $3)) }
1437
1438 aexp2   :: { LHsExpr RdrName }
1439         : ipvar                         { L1 (HsIPVar $! unLoc $1) }
1440         | qcname                        { L1 (HsVar   $! unLoc $1) }
1441         | literal                       { L1 (HsLit   $! unLoc $1) }
1442 -- This will enable overloaded strings permanently.  Normally the renamer turns HsString
1443 -- into HsOverLit when -foverloaded-strings is on.
1444 --      | STRING                        { sL (getLoc $1) (HsOverLit $! mkHsIsString (getSTRING $1) placeHolderType) }
1445         | INTEGER                       { sL (getLoc $1) (HsOverLit $! mkHsIntegral (getINTEGER $1) placeHolderType) }
1446         | RATIONAL                      { sL (getLoc $1) (HsOverLit $! mkHsFractional (getRATIONAL $1) placeHolderType) }
1447
1448         -- N.B.: sections get parsed by these next two productions.
1449         -- This allows you to write, e.g., '(+ 3, 4 -)', which isn't
1450         -- correct Haskell (you'd have to write '((+ 3), (4 -))')
1451         -- but the less cluttered version fell out of having texps.
1452         | '(' texp ')'                  { LL (HsPar $2) }
1453         | '(' tup_exprs ')'             { LL (ExplicitTuple $2 Boxed) }
1454
1455         | '(#' texp '#)'                { LL (ExplicitTuple [Present $2] Unboxed) }
1456         | '(#' tup_exprs '#)'           { LL (ExplicitTuple $2 Unboxed) }
1457
1458         | '[' list ']'                  { LL (unLoc $2) }
1459         | '[:' parr ':]'                { LL (unLoc $2) }
1460         | '_'                           { L1 EWildPat }
1461         
1462         -- Template Haskell Extension
1463         | TH_ID_SPLICE          { L1 $ HsSpliceE (mkHsSplice 
1464                                         (L1 $ HsVar (mkUnqual varName 
1465                                                         (getTH_ID_SPLICE $1)))) } 
1466         | '$(' exp ')'          { LL $ HsSpliceE (mkHsSplice $2) }               
1467
1468
1469         | SIMPLEQUOTE  qvar     { LL $ HsBracket (VarBr True  (unLoc $2)) }
1470         | SIMPLEQUOTE  qcon     { LL $ HsBracket (VarBr True  (unLoc $2)) }
1471         | TH_TY_QUOTE tyvar     { LL $ HsBracket (VarBr False (unLoc $2)) }
1472         | TH_TY_QUOTE gtycon    { LL $ HsBracket (VarBr False (unLoc $2)) }
1473         | '[|' exp '|]'         { LL $ HsBracket (ExpBr $2) }                       
1474         | '[t|' ctype '|]'      { LL $ HsBracket (TypBr $2) }                       
1475         | '[p|' infixexp '|]'   {% checkPattern $2 >>= \p ->
1476                                         return (LL $ HsBracket (PatBr p)) }
1477         | '[d|' cvtopbody '|]'  { LL $ HsBracket (DecBrL $2) }
1478         | quasiquote            { L1 (HsQuasiQuoteE (unLoc $1)) }
1479
1480         -- arrow notation extension
1481         | '(|' aexp2 cmdargs '|)'       { LL $ HsArrForm $2 Nothing (reverse $3) }
1482
1483 cmdargs :: { [LHsCmdTop RdrName] }
1484         : cmdargs acmd                  { $2 : $1 }
1485         | {- empty -}                   { [] }
1486
1487 acmd    :: { LHsCmdTop RdrName }
1488         : aexp2                 { L1 $ HsCmdTop $1 [] placeHolderType undefined }
1489
1490 cvtopbody :: { [LHsDecl RdrName] }
1491         :  '{'            cvtopdecls0 '}'               { $2 }
1492         |      vocurly    cvtopdecls0 close             { $2 }
1493
1494 cvtopdecls0 :: { [LHsDecl RdrName] }
1495         : {- empty -}           { [] }
1496         | cvtopdecls            { $1 }
1497
1498 -----------------------------------------------------------------------------
1499 -- Tuple expressions
1500
1501 -- "texp" is short for tuple expressions: 
1502 -- things that can appear unparenthesized as long as they're
1503 -- inside parens or delimitted by commas
1504 texp :: { LHsExpr RdrName }
1505         : exp                           { $1 }
1506
1507         -- Note [Parsing sections]
1508         -- ~~~~~~~~~~~~~~~~~~~~~~~
1509         -- We include left and right sections here, which isn't
1510         -- technically right according to the Haskell standard.
1511         -- For example (3 +, True) isn't legal.
1512         -- However, we want to parse bang patterns like
1513         --      (!x, !y)
1514         -- and it's convenient to do so here as a section
1515         -- Then when converting expr to pattern we unravel it again
1516         -- Meanwhile, the renamer checks that real sections appear
1517         -- inside parens.
1518         | infixexp qop        { LL $ SectionL $1 $2 }
1519         | qopm infixexp       { LL $ SectionR $1 $2 }
1520
1521        -- View patterns get parenthesized above
1522         | exp '->' texp   { LL $ EViewPat $1 $3 }
1523
1524 -- Always at least one comma
1525 tup_exprs :: { [HsTupArg RdrName] }
1526            : texp commas_tup_tail  { Present $1 : $2 }
1527            | commas tup_tail       { replicate $1 missingTupArg ++ $2 }
1528
1529 -- Always starts with commas; always follows an expr
1530 commas_tup_tail :: { [HsTupArg RdrName] }
1531 commas_tup_tail : commas tup_tail  { replicate ($1-1) missingTupArg ++ $2 }
1532
1533 -- Always follows a comma
1534 tup_tail :: { [HsTupArg RdrName] }
1535           : texp commas_tup_tail        { Present $1 : $2 }
1536           | texp                        { [Present $1] }
1537           | {- empty -}                 { [missingTupArg] }
1538
1539 -----------------------------------------------------------------------------
1540 -- List expressions
1541
1542 -- The rules below are little bit contorted to keep lexps left-recursive while
1543 -- avoiding another shift/reduce-conflict.
1544
1545 list :: { LHsExpr RdrName }
1546         : texp                  { L1 $ ExplicitList placeHolderType [$1] }
1547         | lexps                 { L1 $ ExplicitList placeHolderType (reverse (unLoc $1)) }
1548         | texp '..'             { LL $ ArithSeq noPostTcExpr (From $1) }
1549         | texp ',' exp '..'     { LL $ ArithSeq noPostTcExpr (FromThen $1 $3) }
1550         | texp '..' exp         { LL $ ArithSeq noPostTcExpr (FromTo $1 $3) }
1551         | texp ',' exp '..' exp { LL $ ArithSeq noPostTcExpr (FromThenTo $1 $3 $5) }
1552         | texp '|' flattenedpquals      
1553              {% checkMonadComp >>= \ ctxt ->
1554                 return (sL (comb2 $1 $>) $ 
1555                         mkHsComp ctxt (unLoc $3) $1) }
1556
1557 lexps :: { Located [LHsExpr RdrName] }
1558         : lexps ',' texp                { LL (((:) $! $3) $! unLoc $1) }
1559         | texp ',' texp                 { LL [$3,$1] }
1560
1561 -----------------------------------------------------------------------------
1562 -- List Comprehensions
1563
1564 flattenedpquals :: { Located [LStmt RdrName] }
1565     : pquals   { case (unLoc $1) of
1566                     [qs] -> L1 qs
1567                     -- We just had one thing in our "parallel" list so 
1568                     -- we simply return that thing directly
1569                     
1570                     qss -> L1 [L1 $ ParStmt [(qs, undefined) | qs <- qss] noSyntaxExpr noSyntaxExpr noSyntaxExpr]
1571                     -- We actually found some actual parallel lists so
1572                     -- we wrap them into as a ParStmt
1573                 }
1574
1575 pquals :: { Located [[LStmt RdrName]] }
1576     : squals '|' pquals     { L (getLoc $2) (reverse (unLoc $1) : unLoc $3) }
1577     | squals                { L (getLoc $1) [reverse (unLoc $1)] }
1578
1579 squals :: { Located [LStmt RdrName] }   -- In reverse order, because the last 
1580                                         -- one can "grab" the earlier ones
1581     : squals ',' transformqual               { LL [L (getLoc $3) ((unLoc $3) (reverse (unLoc $1)))] }
1582     | squals ',' qual                        { LL ($3 : unLoc $1) }
1583     | transformqual                          { LL [L (getLoc $1) ((unLoc $1) [])] }
1584     | qual                                   { L1 [$1] }
1585 --  | transformquals1 ',' '{|' pquals '|}'   { LL ($4 : unLoc $1) }
1586 --  | '{|' pquals '|}'                       { L1 [$2] }
1587
1588
1589 -- It is possible to enable bracketing (associating) qualifier lists by uncommenting the lines with {| |}
1590 -- above. Due to a lack of consensus on the syntax, this feature is not being used until we get user
1591 -- demand.
1592
1593 transformqual :: { Located ([LStmt RdrName] -> Stmt RdrName) }
1594                         -- Function is applied to a list of stmts *in order*
1595     : 'then' exp                           { LL $ \leftStmts -> (mkTransformStmt    leftStmts $2)    }
1596     | 'then' exp 'by' exp                  { LL $ \leftStmts -> (mkTransformByStmt  leftStmts $2 $4) }
1597     | 'then' 'group' 'using' exp           { LL $ \leftStmts -> (mkGroupUsingStmt   leftStmts $4)    }
1598     | 'then' 'group' 'by' exp 'using' exp  { LL $ \leftStmts -> (mkGroupByUsingStmt leftStmts $4 $6) }
1599
1600 -- Note that 'group' is a special_id, which means that you can enable
1601 -- TransformListComp while still using Data.List.group. However, this
1602 -- introduces a shift/reduce conflict. Happy chooses to resolve the conflict
1603 -- in by choosing the "group by" variant, which is what we want.
1604
1605 -----------------------------------------------------------------------------
1606 -- Parallel array expressions
1607
1608 -- The rules below are little bit contorted; see the list case for details.
1609 -- Note that, in contrast to lists, we only have finite arithmetic sequences.
1610 -- Moreover, we allow explicit arrays with no element (represented by the nil
1611 -- constructor in the list case).
1612
1613 parr :: { LHsExpr RdrName }
1614         :                               { noLoc (ExplicitPArr placeHolderType []) }
1615         | texp                          { L1 $ ExplicitPArr placeHolderType [$1] }
1616         | lexps                         { L1 $ ExplicitPArr placeHolderType 
1617                                                        (reverse (unLoc $1)) }
1618         | texp '..' exp                 { LL $ PArrSeq noPostTcExpr (FromTo $1 $3) }
1619         | texp ',' exp '..' exp         { LL $ PArrSeq noPostTcExpr (FromThenTo $1 $3 $5) }
1620         | texp '|' flattenedpquals      { LL $ mkHsComp PArrComp (unLoc $3) $1 }
1621
1622 -- We are reusing `lexps' and `flattenedpquals' from the list case.
1623
1624 -----------------------------------------------------------------------------
1625 -- Guards
1626
1627 guardquals :: { Located [LStmt RdrName] }
1628     : guardquals1           { L (getLoc $1) (reverse (unLoc $1)) }
1629
1630 guardquals1 :: { Located [LStmt RdrName] }
1631     : guardquals1 ',' qual  { LL ($3 : unLoc $1) }
1632     | qual                  { L1 [$1] }
1633
1634 -----------------------------------------------------------------------------
1635 -- Case alternatives
1636
1637 altslist :: { Located [LMatch RdrName] }
1638         : '{'            alts '}'       { LL (reverse (unLoc $2)) }
1639         |     vocurly    alts  close    { L (getLoc $2) (reverse (unLoc $2)) }
1640
1641 alts    :: { Located [LMatch RdrName] }
1642         : alts1                         { L1 (unLoc $1) }
1643         | ';' alts                      { LL (unLoc $2) }
1644
1645 alts1   :: { Located [LMatch RdrName] }
1646         : alts1 ';' alt                 { LL ($3 : unLoc $1) }
1647         | alts1 ';'                     { LL (unLoc $1) }
1648         | alt                           { L1 [$1] }
1649
1650 alt     :: { LMatch RdrName }
1651         : pat opt_sig alt_rhs           { LL (Match [$1] $2 (unLoc $3)) }
1652
1653 alt_rhs :: { Located (GRHSs RdrName) }
1654         : ralt wherebinds               { LL (GRHSs (unLoc $1) (unLoc $2)) }
1655
1656 ralt :: { Located [LGRHS RdrName] }
1657         : '->' exp                      { LL (unguardedRHS $2) }
1658         | gdpats                        { L1 (reverse (unLoc $1)) }
1659
1660 gdpats :: { Located [LGRHS RdrName] }
1661         : gdpats gdpat                  { LL ($2 : unLoc $1) }
1662         | gdpat                         { L1 [$1] }
1663
1664 gdpat   :: { LGRHS RdrName }
1665         : '|' guardquals '->' exp               { sL (comb2 $1 $>) $ GRHS (unLoc $2) $4 }
1666
1667 -- 'pat' recognises a pattern, including one with a bang at the top
1668 --      e.g.  "!x" or "!(x,y)" or "C a b" etc
1669 -- Bangs inside are parsed as infix operator applications, so that
1670 -- we parse them right when bang-patterns are off
1671 pat     :: { LPat RdrName }
1672 pat     :  exp                  {% checkPattern $1 }
1673         | '!' aexp              {% checkPattern (LL (SectionR (L1 (HsVar bang_RDR)) $2)) }
1674
1675 apat   :: { LPat RdrName }      
1676 apat    : aexp                  {% checkPattern $1 }
1677         | '!' aexp              {% checkPattern (LL (SectionR (L1 (HsVar bang_RDR)) $2)) }
1678
1679 apats  :: { [LPat RdrName] }
1680         : apat apats            { $1 : $2 }
1681         | {- empty -}           { [] }
1682
1683 -----------------------------------------------------------------------------
1684 -- Statement sequences
1685
1686 stmtlist :: { Located [LStmt RdrName] }
1687         : '{'           stmts '}'       { LL (unLoc $2) }
1688         |     vocurly   stmts close     { $2 }
1689
1690 --      do { ;; s ; s ; ; s ;; }
1691 -- The last Stmt should be an expression, but that's hard to enforce
1692 -- here, because we need too much lookahead if we see do { e ; }
1693 -- So we use ExprStmts throughout, and switch the last one over
1694 -- in ParseUtils.checkDo instead
1695 stmts :: { Located [LStmt RdrName] }
1696         : stmt stmts_help               { LL ($1 : unLoc $2) }
1697         | ';' stmts                     { LL (unLoc $2) }
1698         | {- empty -}                   { noLoc [] }
1699
1700 stmts_help :: { Located [LStmt RdrName] } -- might be empty
1701         : ';' stmts                     { LL (unLoc $2) }
1702         | {- empty -}                   { noLoc [] }
1703
1704 -- For typing stmts at the GHCi prompt, where 
1705 -- the input may consist of just comments.
1706 maybe_stmt :: { Maybe (LStmt RdrName) }
1707         : stmt                          { Just $1 }
1708         | {- nothing -}                 { Nothing }
1709
1710 stmt  :: { LStmt RdrName }
1711         : qual                              { $1 }
1712         | 'rec' stmtlist                { LL $ mkRecStmt (unLoc $2) }
1713
1714 qual  :: { LStmt RdrName }
1715     : pat '<-' exp                      { LL $ mkBindStmt $1 $3 }
1716     | exp                                   { L1 $ mkExprStmt $1 }
1717     | 'let' binds                       { LL $ LetStmt (unLoc $2) }
1718
1719 -----------------------------------------------------------------------------
1720 -- Record Field Update/Construction
1721
1722 fbinds  :: { ([HsRecField RdrName (LHsExpr RdrName)], Bool) }
1723         : fbinds1                       { $1 }
1724         | {- empty -}                   { ([], False) }
1725
1726 fbinds1 :: { ([HsRecField RdrName (LHsExpr RdrName)], Bool) }
1727         : fbind ',' fbinds1             { case $3 of (flds, dd) -> ($1 : flds, dd) } 
1728         | fbind                         { ([$1], False) }
1729         | '..'                          { ([],   True) }
1730   
1731 fbind   :: { HsRecField RdrName (LHsExpr RdrName) }
1732         : qvar '=' exp  { HsRecField $1 $3                False }
1733         | qvar          { HsRecField $1 placeHolderPunRhs True }
1734                         -- In the punning case, use a place-holder
1735                         -- The renamer fills in the final value
1736
1737 -----------------------------------------------------------------------------
1738 -- Implicit Parameter Bindings
1739
1740 dbinds  :: { Located [LIPBind RdrName] }
1741         : dbinds ';' dbind              { let { this = $3; rest = unLoc $1 }
1742                               in rest `seq` this `seq` LL (this : rest) }
1743         | dbinds ';'                    { LL (unLoc $1) }
1744         | dbind                         { let this = $1 in this `seq` L1 [this] }
1745 --      | {- empty -}                   { [] }
1746
1747 dbind   :: { LIPBind RdrName }
1748 dbind   : ipvar '=' exp                 { LL (IPBind (unLoc $1) $3) }
1749
1750 ipvar   :: { Located (IPName RdrName) }
1751         : IPDUPVARID            { L1 (IPName (mkUnqual varName (getIPDUPVARID $1))) }
1752
1753 -----------------------------------------------------------------------------
1754 -- Warnings and deprecations
1755
1756 namelist :: { Located [RdrName] }
1757 namelist : name_var              { L1 [unLoc $1] }
1758          | name_var ',' namelist { LL (unLoc $1 : unLoc $3) }
1759
1760 name_var :: { Located RdrName }
1761 name_var : var { $1 }
1762          | con { $1 }
1763
1764 -----------------------------------------
1765 -- Data constructors
1766 qcon    :: { Located RdrName }
1767         : qconid                { $1 }
1768         | '(' qconsym ')'       { LL (unLoc $2) }
1769         | sysdcon               { L1 $ nameRdrName (dataConName (unLoc $1)) }
1770 -- The case of '[:' ':]' is part of the production `parr'
1771
1772 con     :: { Located RdrName }
1773         : conid                 { $1 }
1774         | '(' consym ')'        { LL (unLoc $2) }
1775         | sysdcon               { L1 $ nameRdrName (dataConName (unLoc $1)) }
1776
1777 con_list :: { Located [Located RdrName] }
1778 con_list : con                  { L1 [$1] }
1779          | con ',' con_list     { LL ($1 : unLoc $3) }
1780
1781 sysdcon :: { Located DataCon }  -- Wired in data constructors
1782         : '(' ')'               { LL unitDataCon }
1783         | '(' commas ')'        { LL $ tupleCon BoxedTuple ($2 + 1) }
1784         | '(#' '#)'             { LL $ unboxedUnitDataCon }
1785         | '(#' commas '#)'      { LL $ tupleCon UnboxedTuple ($2 + 1) }
1786         | '[' ']'               { LL nilDataCon }
1787
1788 conop :: { Located RdrName }
1789         : consym                { $1 }  
1790         | '`' conid '`'         { LL (unLoc $2) }
1791
1792 qconop :: { Located RdrName }
1793         : qconsym               { $1 }
1794         | '`' qconid '`'        { LL (unLoc $2) }
1795
1796 ----------------------------------------------------------------------------
1797 -- Type constructors
1798
1799
1800 -- See Note [Unit tuples] in HsTypes for the distinction 
1801 -- between gtycon and ntgtycon
1802 gtycon :: { Located RdrName }  -- A "general" qualified tycon, including unit tuples
1803         : ntgtycon                      { $1 }
1804         | '(' ')'                       { LL $ getRdrName unitTyCon }
1805         | '(#' '#)'                     { LL $ getRdrName unboxedUnitTyCon }
1806
1807 ntgtycon :: { Located RdrName }  -- A "general" qualified tycon, excluding unit tuples
1808         : oqtycon                       { $1 }
1809         | '(' commas ')'                { LL $ getRdrName (tupleTyCon BoxedTuple ($2 + 1)) }
1810         | '(#' commas '#)'              { LL $ getRdrName (tupleTyCon UnboxedTuple ($2 + 1)) }
1811         | '(' '->' ')'                  { LL $ getRdrName funTyCon }
1812         | '[' ']'                       { LL $ listTyCon_RDR }
1813         | '[:' ':]'                     { LL $ parrTyCon_RDR }
1814         | '(' '~#' ')'                  { LL $ getRdrName eqPrimTyCon }
1815
1816 oqtycon :: { Located RdrName }  -- An "ordinary" qualified tycon;
1817                                 -- These can appear in export lists
1818         : qtycon                        { $1 }
1819         | '(' qtyconsym ')'             { LL (unLoc $2) }
1820         | '(' '~' ')'                   { LL $ eqTyCon_RDR }
1821
1822 qtyconop :: { Located RdrName } -- Qualified or unqualified
1823         : qtyconsym                     { $1 }
1824         | '`' qtycon '`'                { LL (unLoc $2) }
1825
1826 qtycon :: { Located RdrName }   -- Qualified or unqualified
1827         : QCONID                        { L1 $! mkQual tcClsName (getQCONID $1) }
1828         | PREFIXQCONSYM                 { L1 $! mkQual tcClsName (getPREFIXQCONSYM $1) }
1829         | tycon                         { $1 }
1830
1831 tycon   :: { Located RdrName }  -- Unqualified
1832         : CONID                         { L1 $! mkUnqual tcClsName (getCONID $1) }
1833
1834 qtyconsym :: { Located RdrName }
1835         : QCONSYM                       { L1 $! mkQual tcClsName (getQCONSYM $1) }
1836         | tyconsym                      { $1 }
1837
1838 tyconsym :: { Located RdrName }
1839         : CONSYM                        { L1 $! mkUnqual tcClsName (getCONSYM $1) }
1840
1841 -----------------------------------------------------------------------------
1842 -- Operators
1843
1844 op      :: { Located RdrName }   -- used in infix decls
1845         : varop                 { $1 }
1846         | conop                 { $1 }
1847
1848 varop   :: { Located RdrName }
1849         : varsym                { $1 }
1850         | '`' varid '`'         { LL (unLoc $2) }
1851
1852 qop     :: { LHsExpr RdrName }   -- used in sections
1853         : qvarop                { L1 $ HsVar (unLoc $1) }
1854         | qconop                { L1 $ HsVar (unLoc $1) }
1855
1856 qopm    :: { LHsExpr RdrName }   -- used in sections
1857         : qvaropm               { L1 $ HsVar (unLoc $1) }
1858         | qconop                { L1 $ HsVar (unLoc $1) }
1859
1860 qvarop :: { Located RdrName }
1861         : qvarsym               { $1 }
1862         | '`' qvarid '`'        { LL (unLoc $2) }
1863
1864 qvaropm :: { Located RdrName }
1865         : qvarsym_no_minus      { $1 }
1866         | '`' qvarid '`'        { LL (unLoc $2) }
1867
1868 -----------------------------------------------------------------------------
1869 -- Type variables
1870
1871 tyvar   :: { Located RdrName }
1872 tyvar   : tyvarid               { $1 }
1873         | '(' tyvarsym ')'      { LL (unLoc $2) }
1874
1875 tyvarop :: { Located RdrName }
1876 tyvarop : '`' tyvarid '`'       { LL (unLoc $2) }
1877         | tyvarsym              { $1 }
1878         | '.'                   {% parseErrorSDoc (getLoc $1) 
1879                                       (vcat [ptext (sLit "Illegal symbol '.' in type"), 
1880                                              ptext (sLit "Perhaps you intended -XRankNTypes or similar flag"),
1881                                              ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")])
1882                                 }
1883
1884 tyvarid :: { Located RdrName }
1885         : VARID                 { L1 $! mkUnqual tvName (getVARID $1) }
1886         | special_id            { L1 $! mkUnqual tvName (unLoc $1) }
1887         | 'unsafe'              { L1 $! mkUnqual tvName (fsLit "unsafe") }
1888         | 'safe'                { L1 $! mkUnqual tvName (fsLit "safe") }
1889         | 'interruptible'       { L1 $! mkUnqual tvName (fsLit "interruptible") }
1890
1891 tyvarsym :: { Located RdrName }
1892 -- Does not include "!", because that is used for strictness marks
1893 --               or ".", because that separates the quantified type vars from the rest
1894 --               or "*", because that's used for kinds
1895 tyvarsym : VARSYM               { L1 $! mkUnqual tvName (getVARSYM $1) }
1896
1897 -----------------------------------------------------------------------------
1898 -- Variables 
1899
1900 var     :: { Located RdrName }
1901         : varid                 { $1 }
1902         | '(' varsym ')'        { LL (unLoc $2) }
1903
1904 qvar    :: { Located RdrName }
1905         : qvarid                { $1 }
1906         | '(' varsym ')'        { LL (unLoc $2) }
1907         | '(' qvarsym1 ')'      { LL (unLoc $2) }
1908 -- We've inlined qvarsym here so that the decision about
1909 -- whether it's a qvar or a var can be postponed until
1910 -- *after* we see the close paren.
1911
1912 qvarid :: { Located RdrName }
1913         : varid                 { $1 }
1914         | QVARID                { L1 $! mkQual varName (getQVARID $1) }
1915         | PREFIXQVARSYM         { L1 $! mkQual varName (getPREFIXQVARSYM $1) }
1916
1917 varid :: { Located RdrName }
1918         : VARID                 { L1 $! mkUnqual varName (getVARID $1) }
1919         | special_id            { L1 $! mkUnqual varName (unLoc $1) }
1920         | 'unsafe'              { L1 $! mkUnqual varName (fsLit "unsafe") }
1921         | 'safe'                { L1 $! mkUnqual varName (fsLit "safe") }
1922         | 'interruptible'       { L1 $! mkUnqual varName (fsLit "interruptible") }
1923         | 'forall'              { L1 $! mkUnqual varName (fsLit "forall") }
1924         | 'family'              { L1 $! mkUnqual varName (fsLit "family") }
1925
1926 qvarsym :: { Located RdrName }
1927         : varsym                { $1 }
1928         | qvarsym1              { $1 }
1929
1930 qvarsym_no_minus :: { Located RdrName }
1931         : varsym_no_minus       { $1 }
1932         | qvarsym1              { $1 }
1933
1934 qvarsym1 :: { Located RdrName }
1935 qvarsym1 : QVARSYM              { L1 $ mkQual varName (getQVARSYM $1) }
1936
1937 varsym :: { Located RdrName }
1938         : varsym_no_minus       { $1 }
1939         | '-'                   { L1 $ mkUnqual varName (fsLit "-") }
1940
1941 varsym_no_minus :: { Located RdrName } -- varsym not including '-'
1942         : VARSYM                { L1 $ mkUnqual varName (getVARSYM $1) }
1943         | special_sym           { L1 $ mkUnqual varName (unLoc $1) }
1944
1945
1946 -- These special_ids are treated as keywords in various places, 
1947 -- but as ordinary ids elsewhere.   'special_id' collects all these
1948 -- except 'unsafe', 'interruptible', 'forall', and 'family' whose treatment differs
1949 -- depending on context 
1950 special_id :: { Located FastString }
1951 special_id
1952         : 'as'                  { L1 (fsLit "as") }
1953         | 'qualified'           { L1 (fsLit "qualified") }
1954         | 'hiding'              { L1 (fsLit "hiding") }
1955         | 'export'              { L1 (fsLit "export") }
1956         | 'label'               { L1 (fsLit "label")  }
1957         | 'dynamic'             { L1 (fsLit "dynamic") }
1958         | 'stdcall'             { L1 (fsLit "stdcall") }
1959         | 'ccall'               { L1 (fsLit "ccall") }
1960         | 'capi'                { L1 (fsLit "capi") }
1961         | 'prim'                { L1 (fsLit "prim") }
1962         | 'group'               { L1 (fsLit "group") }
1963
1964 special_sym :: { Located FastString }
1965 special_sym : '!'       { L1 (fsLit "!") }
1966             | '.'       { L1 (fsLit ".") }
1967             | '*'       { L1 (fsLit "*") }
1968
1969 -----------------------------------------------------------------------------
1970 -- Data constructors
1971
1972 qconid :: { Located RdrName }   -- Qualified or unqualified
1973         : conid                 { $1 }
1974         | QCONID                { L1 $! mkQual dataName (getQCONID $1) }
1975         | PREFIXQCONSYM         { L1 $! mkQual dataName (getPREFIXQCONSYM $1) }
1976
1977 conid   :: { Located RdrName }
1978         : CONID                 { L1 $ mkUnqual dataName (getCONID $1) }
1979
1980 qconsym :: { Located RdrName }  -- Qualified or unqualified
1981         : consym                { $1 }
1982         | QCONSYM               { L1 $ mkQual dataName (getQCONSYM $1) }
1983
1984 consym :: { Located RdrName }
1985         : CONSYM                { L1 $ mkUnqual dataName (getCONSYM $1) }
1986
1987         -- ':' means only list cons
1988         | ':'                   { L1 $ consDataCon_RDR }
1989
1990
1991 -----------------------------------------------------------------------------
1992 -- Literals
1993
1994 literal :: { Located HsLit }
1995         : CHAR                  { L1 $ HsChar       $ getCHAR $1 }
1996         | STRING                { L1 $ HsString     $ getSTRING $1 }
1997         | PRIMINTEGER           { L1 $ HsIntPrim    $ getPRIMINTEGER $1 }
1998         | PRIMWORD              { L1 $ HsWordPrim    $ getPRIMWORD $1 }
1999         | PRIMCHAR              { L1 $ HsCharPrim   $ getPRIMCHAR $1 }
2000         | PRIMSTRING            { L1 $ HsStringPrim $ getPRIMSTRING $1 }
2001         | PRIMFLOAT             { L1 $ HsFloatPrim  $ getPRIMFLOAT $1 }
2002         | PRIMDOUBLE            { L1 $ HsDoublePrim $ getPRIMDOUBLE $1 }
2003
2004 -----------------------------------------------------------------------------
2005 -- Layout
2006
2007 close :: { () }
2008         : vccurly               { () } -- context popped in lexer.
2009         | error                 {% popContext }
2010
2011 -----------------------------------------------------------------------------
2012 -- Miscellaneous (mostly renamings)
2013
2014 modid   :: { Located ModuleName }
2015         : CONID                 { L1 $ mkModuleNameFS (getCONID $1) }
2016         | QCONID                { L1 $ let (mod,c) = getQCONID $1 in
2017                                   mkModuleNameFS
2018                                    (mkFastString
2019                                      (unpackFS mod ++ '.':unpackFS c))
2020                                 }
2021
2022 commas :: { Int }
2023         : commas ','                    { $1 + 1 }
2024         | ','                           { 1 }
2025
2026 -----------------------------------------------------------------------------
2027 -- Documentation comments
2028
2029 docnext :: { LHsDocString }
2030   : DOCNEXT {% return (L1 (HsDocString (mkFastString (getDOCNEXT $1)))) }
2031
2032 docprev :: { LHsDocString }
2033   : DOCPREV {% return (L1 (HsDocString (mkFastString (getDOCPREV $1)))) }
2034
2035 docnamed :: { Located (String, HsDocString) }
2036   : DOCNAMED {%
2037       let string = getDOCNAMED $1 
2038           (name, rest) = break isSpace string
2039       in return (L1 (name, HsDocString (mkFastString rest))) }
2040
2041 docsection :: { Located (Int, HsDocString) }
2042   : DOCSECTION {% let (n, doc) = getDOCSECTION $1 in
2043         return (L1 (n, HsDocString (mkFastString doc))) }
2044
2045 moduleheader :: { Maybe LHsDocString }
2046         : DOCNEXT {% let string = getDOCNEXT $1 in
2047                      return (Just (L1 (HsDocString (mkFastString string)))) }
2048
2049 maybe_docprev :: { Maybe LHsDocString }
2050         : docprev                       { Just $1 }
2051         | {- empty -}                   { Nothing }
2052
2053 maybe_docnext :: { Maybe LHsDocString }
2054         : docnext                       { Just $1 }
2055         | {- empty -}                   { Nothing }
2056
2057 {
2058 happyError :: P a
2059 happyError = srcParseFail
2060
2061 getVARID        (L _ (ITvarid    x)) = x
2062 getCONID        (L _ (ITconid    x)) = x
2063 getVARSYM       (L _ (ITvarsym   x)) = x
2064 getCONSYM       (L _ (ITconsym   x)) = x
2065 getQVARID       (L _ (ITqvarid   x)) = x
2066 getQCONID       (L _ (ITqconid   x)) = x
2067 getQVARSYM      (L _ (ITqvarsym  x)) = x
2068 getQCONSYM      (L _ (ITqconsym  x)) = x
2069 getPREFIXQVARSYM (L _ (ITprefixqvarsym  x)) = x
2070 getPREFIXQCONSYM (L _ (ITprefixqconsym  x)) = x
2071 getIPDUPVARID   (L _ (ITdupipvarid   x)) = x
2072 getCHAR         (L _ (ITchar     x)) = x
2073 getSTRING       (L _ (ITstring   x)) = x
2074 getINTEGER      (L _ (ITinteger  x)) = x
2075 getRATIONAL     (L _ (ITrational x)) = x
2076 getPRIMCHAR     (L _ (ITprimchar   x)) = x
2077 getPRIMSTRING   (L _ (ITprimstring x)) = x
2078 getPRIMINTEGER  (L _ (ITprimint    x)) = x
2079 getPRIMWORD     (L _ (ITprimword x)) = x
2080 getPRIMFLOAT    (L _ (ITprimfloat  x)) = x
2081 getPRIMDOUBLE   (L _ (ITprimdouble x)) = x
2082 getTH_ID_SPLICE (L _ (ITidEscape x)) = x
2083 getINLINE       (L _ (ITinline_prag inl conl)) = (inl,conl)
2084 getSPEC_INLINE  (L _ (ITspec_inline_prag True))  = (Inline,  FunLike)
2085 getSPEC_INLINE  (L _ (ITspec_inline_prag False)) = (NoInline,FunLike)
2086
2087 getDOCNEXT (L _ (ITdocCommentNext x)) = x
2088 getDOCPREV (L _ (ITdocCommentPrev x)) = x
2089 getDOCNAMED (L _ (ITdocCommentNamed x)) = x
2090 getDOCSECTION (L _ (ITdocSection n x)) = (n, x)
2091
2092 getSCC :: Located Token -> P FastString
2093 getSCC lt = do let s = getSTRING lt
2094                    err = "Spaces are not allowed in SCCs"
2095                -- We probably actually want to be more restrictive than this
2096                if ' ' `elem` unpackFS s
2097                    then failSpanMsgP (getLoc lt) (text err)
2098                    else return s
2099
2100 -- Utilities for combining source spans
2101 comb2 :: Located a -> Located b -> SrcSpan
2102 comb2 a b = a `seq` b `seq` combineLocs a b
2103
2104 comb3 :: Located a -> Located b -> Located c -> SrcSpan
2105 comb3 a b c = a `seq` b `seq` c `seq`
2106     combineSrcSpans (getLoc a) (combineSrcSpans (getLoc b) (getLoc c))
2107
2108 comb4 :: Located a -> Located b -> Located c -> Located d -> SrcSpan
2109 comb4 a b c d = a `seq` b `seq` c `seq` d `seq`
2110     (combineSrcSpans (getLoc a) $ combineSrcSpans (getLoc b) $
2111                 combineSrcSpans (getLoc c) (getLoc d))
2112
2113 -- strict constructor version:
2114 {-# INLINE sL #-}
2115 sL :: SrcSpan -> a -> Located a
2116 sL span a = span `seq` a `seq` L span a
2117
2118 -- Make a source location for the file.  We're a bit lazy here and just
2119 -- make a point SrcSpan at line 1, column 0.  Strictly speaking we should
2120 -- try to find the span of the whole file (ToDo).
2121 fileSrcSpan :: P SrcSpan
2122 fileSrcSpan = do 
2123   l <- getSrcLoc; 
2124   let loc = mkSrcLoc (srcLocFile l) 1 1;
2125   return (mkSrcSpan loc loc)
2126 }