Merge remote-tracking branch 'origin/master' into type-nats
[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  vocurly        { L _ ITvocurly } -- virtual open curly (from layout)
298  vccurly        { L _ ITvccurly } -- virtual close curly (from layout)
299  '['            { L _ ITobrack }
300  ']'            { L _ ITcbrack }
301  '[:'           { L _ ITopabrack }
302  ':]'           { L _ ITcpabrack }
303  '('            { L _ IToparen }
304  ')'            { L _ ITcparen }
305  '(#'           { L _ IToubxparen }
306  '#)'           { L _ ITcubxparen }
307  '(|'           { L _ IToparenbar }
308  '|)'           { L _ ITcparenbar }
309  ';'            { L _ ITsemi }
310  ','            { L _ ITcomma }
311  '`'            { L _ ITbackquote }
312  SIMPLEQUOTE    { L _ ITsimpleQuote      }     -- 'x
313
314  VARID          { L _ (ITvarid    _) }          -- identifiers
315  CONID          { L _ (ITconid    _) }
316  VARSYM         { L _ (ITvarsym   _) }
317  CONSYM         { L _ (ITconsym   _) }
318  QVARID         { L _ (ITqvarid   _) }
319  QCONID         { L _ (ITqconid   _) }
320  QVARSYM        { L _ (ITqvarsym  _) }
321  QCONSYM        { L _ (ITqconsym  _) }
322  PREFIXQVARSYM  { L _ (ITprefixqvarsym  _) }
323  PREFIXQCONSYM  { L _ (ITprefixqconsym  _) }
324
325  IPDUPVARID     { L _ (ITdupipvarid   _) }              -- GHC extension
326
327  CHAR           { L _ (ITchar     _) }
328  STRING         { L _ (ITstring   _) }
329  INTEGER        { L _ (ITinteger  _) }
330  RATIONAL       { L _ (ITrational _) }
331                     
332  PRIMCHAR       { L _ (ITprimchar   _) }
333  PRIMSTRING     { L _ (ITprimstring _) }
334  PRIMINTEGER    { L _ (ITprimint    _) }
335  PRIMWORD       { L _ (ITprimword  _) }
336  PRIMFLOAT      { L _ (ITprimfloat  _) }
337  PRIMDOUBLE     { L _ (ITprimdouble _) }
338
339  DOCNEXT        { L _ (ITdocCommentNext _) }
340  DOCPREV        { L _ (ITdocCommentPrev _) }
341  DOCNAMED       { L _ (ITdocCommentNamed _) }
342  DOCSECTION     { L _ (ITdocSection _ _) }
343
344 -- Template Haskell 
345 '[|'            { L _ ITopenExpQuote  }       
346 '[p|'           { L _ ITopenPatQuote  }      
347 '[t|'           { L _ ITopenTypQuote  }      
348 '[d|'           { L _ ITopenDecQuote  }      
349 '|]'            { L _ ITcloseQuote    }
350 TH_ID_SPLICE    { L _ (ITidEscape _)  }     -- $x
351 '$('            { L _ ITparenEscape   }     -- $( exp )
352 TH_TY_QUOTE     { L _ ITtyQuote       }      -- ''T
353 TH_QUASIQUOTE   { L _ (ITquasiQuote _) }
354
355 %monad { P } { >>= } { return }
356 %lexer { lexer } { L _ ITeof }
357 %name parseModule module
358 %name parseStmt   maybe_stmt
359 %name parseIdentifier  identifier
360 %name parseType ctype
361 %partial parseHeader header
362 %tokentype { (Located Token) }
363 %%
364
365 -----------------------------------------------------------------------------
366 -- Identifiers; one of the entry points
367 identifier :: { Located RdrName }
368         : qvar                          { $1 }
369         | qcon                          { $1 }
370         | qvarop                        { $1 }
371         | qconop                        { $1 }
372     | '(' '->' ')'      { LL $ getRdrName funTyCon }
373
374 -----------------------------------------------------------------------------
375 -- Module Header
376
377 -- The place for module deprecation is really too restrictive, but if it
378 -- was allowed at its natural place just before 'module', we get an ugly
379 -- s/r conflict with the second alternative. Another solution would be the
380 -- introduction of a new pragma DEPRECATED_MODULE, but this is not very nice,
381 -- either, and DEPRECATED is only expected to be used by people who really
382 -- know what they are doing. :-)
383
384 module  :: { Located (HsModule RdrName) }
385         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' body
386                 {% fileSrcSpan >>= \ loc ->
387                    return (L loc (HsModule (Just $3) $5 (fst $7) (snd $7) $4 $1
388                           ) )}
389         | body2
390                 {% fileSrcSpan >>= \ loc ->
391                    return (L loc (HsModule Nothing Nothing
392                           (fst $1) (snd $1) Nothing Nothing
393                           )) }
394
395 maybedocheader :: { Maybe LHsDocString }
396         : moduleheader            { $1 }
397         | {- empty -}             { Nothing }
398
399 missing_module_keyword :: { () }
400         : {- empty -}                           {% pushCurrentContext }
401
402 maybemodwarning :: { Maybe WarningTxt }
403     : '{-# DEPRECATED' strings '#-}' { Just (DeprecatedTxt $ unLoc $2) }
404     | '{-# WARNING' strings '#-}'    { Just (WarningTxt $ unLoc $2) }
405     |  {- empty -}                  { Nothing }
406
407 body    :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }
408         :  '{'            top '}'               { $2 }
409         |      vocurly    top close             { $2 }
410
411 body2   :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }
412         :  '{' top '}'                          { $2 }
413         |  missing_module_keyword top close     { $2 }
414
415 top     :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }
416         : importdecls                           { (reverse $1,[]) }
417         | importdecls ';' cvtopdecls            { (reverse $1,$3) }
418         | cvtopdecls                            { ([],$1) }
419
420 cvtopdecls :: { [LHsDecl RdrName] }
421         : topdecls                              { cvTopDecls $1 }
422
423 -----------------------------------------------------------------------------
424 -- Module declaration & imports only
425
426 header  :: { Located (HsModule RdrName) }
427         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' header_body
428                 {% fileSrcSpan >>= \ loc ->
429                    return (L loc (HsModule (Just $3) $5 $7 [] $4 $1
430                           ))}
431         | header_body2
432                 {% fileSrcSpan >>= \ loc ->
433                    return (L loc (HsModule Nothing Nothing $1 [] Nothing
434                           Nothing)) }
435
436 header_body :: { [LImportDecl RdrName] }
437         :  '{'            importdecls           { $2 }
438         |      vocurly    importdecls           { $2 }
439
440 header_body2 :: { [LImportDecl RdrName] }
441         :  '{' importdecls                      { $2 }
442         |  missing_module_keyword importdecls   { $2 }
443
444 -----------------------------------------------------------------------------
445 -- The Export List
446
447 maybeexports :: { Maybe [LIE RdrName] }
448         :  '(' exportlist ')'                   { Just $2 }
449         |  {- empty -}                          { Nothing }
450
451 exportlist :: { [LIE RdrName] }
452         : expdoclist ',' expdoclist             { $1 ++ $3 }
453         | exportlist1                           { $1 }
454
455 exportlist1 :: { [LIE RdrName] }
456         : expdoclist export expdoclist ',' exportlist  { $1 ++ ($2 : $3) ++ $5 }
457         | expdoclist export expdoclist                 { $1 ++ ($2 : $3) }
458         | expdoclist                                   { $1 }
459
460 expdoclist :: { [LIE RdrName] }
461         : exp_doc expdoclist                           { $1 : $2 }
462         | {- empty -}                                  { [] }
463
464 exp_doc :: { LIE RdrName }                                                   
465         : docsection    { L1 (case (unLoc $1) of (n, doc) -> IEGroup n doc) }
466         | docnamed      { L1 (IEDocNamed ((fst . unLoc) $1)) } 
467         | docnext       { L1 (IEDoc (unLoc $1)) }       
468
469
470    -- No longer allow things like [] and (,,,) to be exported
471    -- They are built in syntax, always available
472 export  :: { LIE RdrName }
473         : qcname_ext export_subspec     { LL (mkModuleImpExp (unLoc $1)
474                                                              (unLoc $2)) }
475         |  'module' modid               { LL (IEModuleContents (unLoc $2)) }
476
477 export_subspec :: { Located ImpExpSubSpec }
478         : {- empty -}                   { L0 ImpExpAbs }
479         | '(' '..' ')'                  { LL ImpExpAll }
480         | '(' ')'                       { LL (ImpExpList []) }
481         | '(' qcnames ')'               { LL (ImpExpList (reverse $2)) }
482
483 qcnames :: { [RdrName] }     -- A reversed list
484         :  qcnames ',' qcname_ext       { unLoc $3 : $1 }
485         |  qcname_ext                   { [unLoc $1]  }
486
487 qcname_ext :: { Located RdrName }       -- Variable or data constructor
488                                         -- or tagged type constructor
489         :  qcname                       { $1 }
490         |  'type' qcname                { sL (comb2 $1 $2) 
491                                              (setRdrNameSpace (unLoc $2) 
492                                                               tcClsName)  }
493
494 -- Cannot pull into qcname_ext, as qcname is also used in expression.
495 qcname  :: { Located RdrName }  -- Variable or data constructor
496         :  qvar                         { $1 }
497         |  qcon                         { $1 }
498
499 -----------------------------------------------------------------------------
500 -- Import Declarations
501
502 -- import decls can be *empty*, or even just a string of semicolons
503 -- whereas topdecls must contain at least one topdecl.
504
505 importdecls :: { [LImportDecl RdrName] }
506         : importdecls ';' importdecl            { $3 : $1 }
507         | importdecls ';'                       { $1 }
508         | importdecl                            { [ $1 ] }
509         | {- empty -}                           { [] }
510
511 importdecl :: { LImportDecl RdrName }
512         : 'import' maybe_src maybe_safe optqualified maybe_pkg modid maybeas maybeimpspec 
513                 { L (comb4 $1 $6 $7 $8) $
514                   ImportDecl { ideclName = $6, ideclPkgQual = $5
515                              , ideclSource = $2, ideclSafe = $3
516                              , ideclQualified = $4, ideclImplicit = False
517                              , ideclAs = unLoc $7, ideclHiding = unLoc $8 } }
518
519 maybe_src :: { IsBootInterface }
520         : '{-# SOURCE' '#-}'                    { True }
521         | {- empty -}                           { False }
522
523 maybe_safe :: { Bool }
524         : 'safe'                                { True }
525         | {- empty -}                           { False }
526
527 maybe_pkg :: { Maybe FastString }
528         : STRING                                { Just (getSTRING $1) }
529         | {- empty -}                           { Nothing }
530
531 optqualified :: { Bool }
532         : 'qualified'                           { True  }
533         | {- empty -}                           { False }
534
535 maybeas :: { Located (Maybe ModuleName) }
536         : 'as' modid                            { LL (Just (unLoc $2)) }
537         | {- empty -}                           { noLoc Nothing }
538
539 maybeimpspec :: { Located (Maybe (Bool, [LIE RdrName])) }
540         : impspec                               { L1 (Just (unLoc $1)) }
541         | {- empty -}                           { noLoc Nothing }
542
543 impspec :: { Located (Bool, [LIE RdrName]) }
544         :  '(' exportlist ')'                   { LL (False, $2) }
545         |  'hiding' '(' exportlist ')'          { LL (True,  $3) }
546
547 -----------------------------------------------------------------------------
548 -- Fixity Declarations
549
550 prec    :: { Int }
551         : {- empty -}           { 9 }
552         | INTEGER               {% checkPrecP (L1 (fromInteger (getINTEGER $1))) }
553
554 infix   :: { Located FixityDirection }
555         : 'infix'                               { L1 InfixN  }
556         | 'infixl'                              { L1 InfixL  }
557         | 'infixr'                              { L1 InfixR }
558
559 ops     :: { Located [Located RdrName] }
560         : ops ',' op                            { LL ($3 : unLoc $1) }
561         | op                                    { L1 [$1] }
562
563 -----------------------------------------------------------------------------
564 -- Top-Level Declarations
565
566 topdecls :: { OrdList (LHsDecl RdrName) }
567         : topdecls ';' topdecl                  { $1 `appOL` $3 }
568         | topdecls ';'                          { $1 }
569         | topdecl                               { $1 }
570
571 topdecl :: { OrdList (LHsDecl RdrName) }
572         : cl_decl                               { unitOL (L1 (TyClD (unLoc $1))) }
573         | ty_decl                               { unitOL (L1 (TyClD (unLoc $1))) }
574         | inst_decl                             { unitOL (L1 (InstD (unLoc $1))) }
575         | stand_alone_deriving                  { unitOL (LL (DerivD (unLoc $1))) }
576         | 'default' '(' comma_types0 ')'        { unitOL (LL $ DefD (DefaultDecl $3)) }
577         | 'foreign' fdecl                       { unitOL (LL (unLoc $2)) }
578         | '{-# DEPRECATED' deprecations '#-}'   { $2 }
579         | '{-# WARNING' warnings '#-}'          { $2 }
580         | '{-# RULES' rules '#-}'               { $2 }
581         | '{-# VECTORISE_SCALAR' qvar '#-}'     { unitOL $ LL $ VectD (HsVect       $2 Nothing) }
582         | '{-# VECTORISE' qvar '=' exp '#-}'    { unitOL $ LL $ VectD (HsVect       $2 (Just $4)) }
583         | '{-# NOVECTORISE' qvar '#-}'          { unitOL $ LL $ VectD (HsNoVect     $2) }
584         | '{-# VECTORISE' 'type' gtycon '#-}'     
585                                                 { unitOL $ LL $ 
586                                                     VectD (HsVectTypeIn False $3 Nothing) }
587         | '{-# VECTORISE_SCALAR' 'type' gtycon '#-}'     
588                                                 { unitOL $ LL $ 
589                                                     VectD (HsVectTypeIn True $3 Nothing) }
590         | '{-# VECTORISE' 'type' gtycon '=' gtycon '#-}'     
591                                                 { unitOL $ LL $ 
592                                                     VectD (HsVectTypeIn False $3 (Just $5)) }
593         | '{-# VECTORISE_SCALAR' 'type' gtycon '=' gtycon '#-}'     
594                                                 { unitOL $ LL $ 
595                                                     VectD (HsVectTypeIn True $3 (Just $5)) }
596         | '{-# VECTORISE' 'class' gtycon '#-}'  { unitOL $ LL $ VectD (HsVectClassIn $3) }
597         | '{-# VECTORISE_SCALAR' 'instance' type '#-}'     
598                                                 { unitOL $ LL $ VectD (HsVectInstIn $3) }
599         | annotation { unitOL $1 }
600         | decl                                  { unLoc $1 }
601
602         -- Template Haskell Extension
603         -- The $(..) form is one possible form of infixexp
604         -- but we treat an arbitrary expression just as if 
605         -- it had a $(..) wrapped around it
606         | infixexp                              { unitOL (LL $ mkTopSpliceDecl $1) } 
607
608 -- Type classes
609 --
610 cl_decl :: { LTyClDecl RdrName }
611         : 'class' tycl_hdr fds where_cls        {% mkClassDecl (comb4 $1 $2 $3 $4) $2 $3 $4 }
612
613 -- Type declarations (toplevel)
614 --
615 ty_decl :: { LTyClDecl RdrName }
616            -- ordinary type synonyms
617         : 'type' type '=' ctypedoc
618                 -- Note ctype, not sigtype, on the right of '='
619                 -- We allow an explicit for-all but we don't insert one
620                 -- in   type Foo a = (b,b)
621                 -- Instead we just say b is out of scope
622                 --
623                 -- Note the use of type for the head; this allows
624                 -- infix type constructors to be declared 
625                 {% mkTySynonym (comb2 $1 $4) False $2 $4 }
626
627            -- type family declarations
628         | 'type' 'family' type opt_kind_sig 
629                 -- Note the use of type for the head; this allows
630                 -- infix type constructors to be declared
631                 {% mkTyFamily (comb3 $1 $3 $4) TypeFamily $3 (unLoc $4) }
632
633           -- ordinary data type or newtype declaration
634         | data_or_newtype tycl_hdr constrs deriving
635                 {% mkTyData (comb4 $1 $2 $3 $4) (unLoc $1) False $2 
636                             Nothing (reverse (unLoc $3)) (unLoc $4) }
637                                    -- We need the location on tycl_hdr in case 
638                                    -- constrs and deriving are both empty
639
640           -- ordinary GADT declaration
641         | data_or_newtype tycl_hdr opt_kind_sig 
642                  gadt_constrlist
643                  deriving
644                 {% mkTyData (comb4 $1 $2 $4 $5) (unLoc $1) False $2 
645                             (unLoc $3) (unLoc $4) (unLoc $5) }
646                                    -- We need the location on tycl_hdr in case 
647                                    -- constrs and deriving are both empty
648
649           -- data/newtype family
650         | 'data' 'family' type opt_kind_sig
651                 {% mkTyFamily (comb3 $1 $2 $4) DataFamily $3 (unLoc $4) }
652
653 inst_decl :: { LInstDecl RdrName }
654         : 'instance' inst_type where_inst
655                  { let (binds, sigs, ats, _) = cvBindsAndSigs (unLoc $3)
656                    in L (comb3 $1 $2 $3) (ClsInstDecl $2 binds sigs ats) }
657
658            -- type instance declarations
659         | 'type' 'instance' type '=' ctype
660                 -- Note the use of type for the head; this allows
661                 -- infix type constructors and type patterns
662                 {% do { L loc d <- mkTySynonym (comb2 $1 $5) True $3 $5
663                       ; return (L loc (FamInstDecl d)) } }
664
665           -- data/newtype instance declaration
666         | data_or_newtype 'instance' tycl_hdr constrs deriving
667                 {% do { L loc d <- mkTyData (comb4 $1 $3 $4 $5) (unLoc $1) True $3
668                                       Nothing (reverse (unLoc $4)) (unLoc $5)
669                       ; return (L loc (FamInstDecl d)) } }
670
671           -- GADT instance declaration
672         | data_or_newtype 'instance' tycl_hdr opt_kind_sig 
673                  gadt_constrlist
674                  deriving
675                 {% do { L loc d <- mkTyData (comb4 $1 $3 $5 $6) (unLoc $1) True $3
676                                             (unLoc $4) (unLoc $5) (unLoc $6)
677                       ; return (L loc (FamInstDecl d)) } }
678         
679 -- Associated type family declarations
680 --
681 -- * They have a different syntax than on the toplevel (no family special
682 --   identifier).
683 --
684 -- * They also need to be separate from instances; otherwise, data family
685 --   declarations without a kind signature cause parsing conflicts with empty
686 --   data declarations. 
687 --
688 at_decl_cls :: { LTyClDecl RdrName }
689            -- type family declarations
690         : 'type' type opt_kind_sig
691                 -- Note the use of type for the head; this allows
692                 -- infix type constructors to be declared
693                 {% mkTyFamily (comb3 $1 $2 $3) TypeFamily $2 (unLoc $3) }
694
695            -- default type instance
696         | 'type' type '=' ctype
697                 -- Note the use of type for the head; this allows
698                 -- infix type constructors and type patterns
699                 {% mkTySynonym (comb2 $1 $4) True $2 $4 }
700
701           -- data/newtype family declaration
702         | 'data' type opt_kind_sig
703                 {% mkTyFamily (comb3 $1 $2 $3) DataFamily $2 (unLoc $3) }
704
705 -- Associated type instances
706 --
707 at_decl_inst :: { LTyClDecl RdrName }
708            -- type instance declarations
709         : 'type' type '=' ctype
710                 -- Note the use of type for the head; this allows
711                 -- infix type constructors and type patterns
712                 {% mkTySynonym (comb2 $1 $4) True $2 $4 }
713
714         -- data/newtype instance declaration
715         | data_or_newtype tycl_hdr constrs deriving
716                 {% mkTyData (comb4 $1 $2 $3 $4) (unLoc $1) True $2 
717                             Nothing (reverse (unLoc $3)) (unLoc $4) }
718
719         -- GADT instance declaration
720         | data_or_newtype tycl_hdr opt_kind_sig 
721                  gadt_constrlist
722                  deriving
723                 {% mkTyData (comb4 $1 $2 $4 $5) (unLoc $1) True $2 
724                             (unLoc $3) (unLoc $4) (unLoc $5) }
725
726 data_or_newtype :: { Located NewOrData }
727         : 'data'        { L1 DataType }
728         | 'newtype'     { L1 NewType }
729
730 opt_kind_sig :: { Located (Maybe (LHsKind RdrName)) }
731         :                               { noLoc Nothing }
732         | '::' kind                     { LL (Just $2) }
733
734 -- tycl_hdr parses the header of a class or data type decl,
735 -- which takes the form
736 --      T a b
737 --      Eq a => T a
738 --      (Eq a, Ord b) => T a b
739 --      T Int [a]                       -- for associated types
740 -- Rather a lot of inlining here, else we get reduce/reduce errors
741 tycl_hdr :: { Located (Maybe (LHsContext RdrName), LHsType RdrName) }
742         : context '=>' type             { LL (Just $1, $3) }
743         | type                          { L1 (Nothing, $1) }
744
745 -----------------------------------------------------------------------------
746 -- Stand-alone deriving
747
748 -- Glasgow extension: stand-alone deriving declarations
749 stand_alone_deriving :: { LDerivDecl RdrName }
750         : 'deriving' 'instance' inst_type { LL (DerivDecl $3) }
751
752 -----------------------------------------------------------------------------
753 -- Nested declarations
754
755 -- Declaration in class bodies
756 --
757 decl_cls  :: { Located (OrdList (LHsDecl RdrName)) }
758 decl_cls  : at_decl_cls                 { LL (unitOL (L1 (TyClD (unLoc $1)))) }
759           | decl                        { $1 }
760
761           -- A 'default' signature used with the generic-programming extension
762           | 'default' infixexp '::' sigtypedoc
763                     {% do { (TypeSig l ty) <- checkValSig $2 $4
764                           ; return (LL $ unitOL (LL $ SigD (GenericSig l ty))) } }
765
766 decls_cls :: { Located (OrdList (LHsDecl RdrName)) }    -- Reversed
767           : decls_cls ';' decl_cls      { LL (unLoc $1 `appOL` unLoc $3) }
768           | decls_cls ';'               { LL (unLoc $1) }
769           | decl_cls                    { $1 }
770           | {- empty -}                 { noLoc nilOL }
771
772
773 decllist_cls
774         :: { Located (OrdList (LHsDecl RdrName)) }      -- Reversed
775         : '{'         decls_cls '}'     { LL (unLoc $2) }
776         |     vocurly decls_cls close   { $2 }
777
778 -- Class body
779 --
780 where_cls :: { Located (OrdList (LHsDecl RdrName)) }    -- Reversed
781                                 -- No implicit parameters
782                                 -- May have type declarations
783         : 'where' decllist_cls          { LL (unLoc $2) }
784         | {- empty -}                   { noLoc nilOL }
785
786 -- Declarations in instance bodies
787 --
788 decl_inst  :: { Located (OrdList (LHsDecl RdrName)) }
789 decl_inst  : at_decl_inst               { LL (unitOL (L1 (TyClD (unLoc $1)))) }
790            | decl                       { $1 }
791
792 decls_inst :: { Located (OrdList (LHsDecl RdrName)) }   -- Reversed
793            : decls_inst ';' decl_inst   { LL (unLoc $1 `appOL` unLoc $3) }
794            | decls_inst ';'             { LL (unLoc $1) }
795            | decl_inst                  { $1 }
796            | {- empty -}                { noLoc nilOL }
797
798 decllist_inst 
799         :: { Located (OrdList (LHsDecl RdrName)) }      -- Reversed
800         : '{'         decls_inst '}'    { LL (unLoc $2) }
801         |     vocurly decls_inst close  { $2 }
802
803 -- Instance body
804 --
805 where_inst :: { Located (OrdList (LHsDecl RdrName)) }   -- Reversed
806                                 -- No implicit parameters
807                                 -- May have type declarations
808         : 'where' decllist_inst         { LL (unLoc $2) }
809         | {- empty -}                   { noLoc nilOL }
810
811 -- Declarations in binding groups other than classes and instances
812 --
813 decls   :: { Located (OrdList (LHsDecl RdrName)) }      
814         : decls ';' decl                { let { this = unLoc $3;
815                                     rest = unLoc $1;
816                                     these = rest `appOL` this }
817                               in rest `seq` this `seq` these `seq`
818                                     LL these }
819         | decls ';'                     { LL (unLoc $1) }
820         | decl                          { $1 }
821         | {- empty -}                   { noLoc nilOL }
822
823 decllist :: { Located (OrdList (LHsDecl RdrName)) }
824         : '{'            decls '}'      { LL (unLoc $2) }
825         |     vocurly    decls close    { $2 }
826
827 -- Binding groups other than those of class and instance declarations
828 --
829 binds   ::  { Located (HsLocalBinds RdrName) }          -- May have implicit parameters
830                                                 -- No type declarations
831         : decllist                      { L1 (HsValBinds (cvBindGroup (unLoc $1))) }
832         | '{'            dbinds '}'     { LL (HsIPBinds (IPBinds (unLoc $2) emptyTcEvBinds)) }
833         |     vocurly    dbinds close   { L (getLoc $2) (HsIPBinds (IPBinds (unLoc $2) emptyTcEvBinds)) }
834
835 wherebinds :: { Located (HsLocalBinds RdrName) }        -- May have implicit parameters
836                                                 -- No type declarations
837         : 'where' binds                 { LL (unLoc $2) }
838         | {- empty -}                   { noLoc emptyLocalBinds }
839
840
841 -----------------------------------------------------------------------------
842 -- Transformation Rules
843
844 rules   :: { OrdList (LHsDecl RdrName) }
845         :  rules ';' rule                       { $1 `snocOL` $3 }
846         |  rules ';'                            { $1 }
847         |  rule                                 { unitOL $1 }
848         |  {- empty -}                          { nilOL }
849
850 rule    :: { LHsDecl RdrName }
851         : STRING activation rule_forall infixexp '=' exp
852              { LL $ RuleD (HsRule (getSTRING $1) 
853                                   ($2 `orElse` AlwaysActive) 
854                                   $3 $4 placeHolderNames $6 placeHolderNames) }
855
856 activation :: { Maybe Activation } 
857         : {- empty -}                           { Nothing }
858         | explicit_activation                   { Just $1 }
859
860 explicit_activation :: { Activation }  -- In brackets
861         : '[' INTEGER ']'               { ActiveAfter  (fromInteger (getINTEGER $2)) }
862         | '[' '~' INTEGER ']'           { ActiveBefore (fromInteger (getINTEGER $3)) }
863
864 rule_forall :: { [RuleBndr RdrName] }
865         : 'forall' rule_var_list '.'            { $2 }
866         | {- empty -}                           { [] }
867
868 rule_var_list :: { [RuleBndr RdrName] }
869         : rule_var                              { [$1] }
870         | rule_var rule_var_list                { $1 : $2 }
871
872 rule_var :: { RuleBndr RdrName }
873         : varid                                 { RuleBndr $1 }
874         | '(' varid '::' ctype ')'              { RuleBndrSig $2 $4 }
875
876 -----------------------------------------------------------------------------
877 -- Warnings and deprecations (c.f. rules)
878
879 warnings :: { OrdList (LHsDecl RdrName) }
880         : warnings ';' warning          { $1 `appOL` $3 }
881         | warnings ';'                  { $1 }
882         | warning                               { $1 }
883         | {- empty -}                           { nilOL }
884
885 -- SUP: TEMPORARY HACK, not checking for `module Foo'
886 warning :: { OrdList (LHsDecl RdrName) }
887         : namelist strings
888                 { toOL [ LL $ WarningD (Warning n (WarningTxt $ unLoc $2))
889                        | n <- unLoc $1 ] }
890
891 deprecations :: { OrdList (LHsDecl RdrName) }
892         : deprecations ';' deprecation          { $1 `appOL` $3 }
893         | deprecations ';'                      { $1 }
894         | deprecation                           { $1 }
895         | {- empty -}                           { nilOL }
896
897 -- SUP: TEMPORARY HACK, not checking for `module Foo'
898 deprecation :: { OrdList (LHsDecl RdrName) }
899         : namelist strings
900                 { toOL [ LL $ WarningD (Warning n (DeprecatedTxt $ unLoc $2))
901                        | n <- unLoc $1 ] }
902
903 strings :: { Located [FastString] }
904     : STRING { L1 [getSTRING $1] }
905     | '[' stringlist ']' { LL $ fromOL (unLoc $2) }
906
907 stringlist :: { Located (OrdList FastString) }
908     : stringlist ',' STRING { LL (unLoc $1 `snocOL` getSTRING $3) }
909     | STRING                { LL (unitOL (getSTRING $1)) }
910
911 -----------------------------------------------------------------------------
912 -- Annotations
913 annotation :: { LHsDecl RdrName }
914     : '{-# ANN' name_var aexp '#-}'      { LL (AnnD $ HsAnnotation (ValueAnnProvenance (unLoc $2)) $3) }
915     | '{-# ANN' 'type' tycon aexp '#-}'  { LL (AnnD $ HsAnnotation (TypeAnnProvenance (unLoc $3)) $4) }
916     | '{-# ANN' 'module' aexp '#-}'      { LL (AnnD $ HsAnnotation ModuleAnnProvenance $3) }
917
918
919 -----------------------------------------------------------------------------
920 -- Foreign import and export declarations
921
922 fdecl :: { LHsDecl RdrName }
923 fdecl : 'import' callconv safety fspec
924                 {% mkImport $2 $3 (unLoc $4) >>= return.LL }
925       | 'import' callconv        fspec          
926                 {% do { d <- mkImport $2 PlaySafe (unLoc $3);
927                         return (LL d) } }
928       | 'export' callconv fspec
929                 {% mkExport $2 (unLoc $3) >>= return.LL }
930
931 callconv :: { CCallConv }
932           : 'stdcall'                   { StdCallConv }
933           | 'ccall'                     { CCallConv   }
934           | 'capi'                      { CApiConv    }
935           | 'prim'                      { PrimCallConv}
936
937 safety :: { Safety }
938         : 'unsafe'                      { PlayRisky }
939         | 'safe'                        { PlaySafe }
940         | 'interruptible'               { PlayInterruptible }
941
942 fspec :: { Located (Located FastString, Located RdrName, LHsType RdrName) }
943        : STRING var '::' sigtypedoc     { LL (L (getLoc $1) (getSTRING $1), $2, $4) }
944        |        var '::' sigtypedoc     { LL (noLoc nilFS, $1, $3) }
945          -- if the entity string is missing, it defaults to the empty string;
946          -- the meaning of an empty entity string depends on the calling
947          -- convention
948
949 -----------------------------------------------------------------------------
950 -- Type signatures
951
952 opt_sig :: { Maybe (LHsType RdrName) }
953         : {- empty -}                   { Nothing }
954         | '::' sigtype                  { Just $2 }
955
956 opt_asig :: { Maybe (LHsType RdrName) }
957         : {- empty -}                   { Nothing }
958         | '::' atype                    { Just $2 }
959
960 sigtype :: { LHsType RdrName }          -- Always a HsForAllTy,
961                                         -- to tell the renamer where to generalise
962         : ctype                         { L1 (mkImplicitHsForAllTy (noLoc []) $1) }
963         -- Wrap an Implicit forall if there isn't one there already
964
965 sigtypedoc :: { LHsType RdrName }       -- Always a HsForAllTy
966         : ctypedoc                      { L1 (mkImplicitHsForAllTy (noLoc []) $1) }
967         -- Wrap an Implicit forall if there isn't one there already
968
969 sig_vars :: { Located [Located RdrName] }
970          : sig_vars ',' var             { LL ($3 : unLoc $1) }
971          | var                          { L1 [$1] }
972
973 sigtypes1 :: { [LHsType RdrName] }      -- Always HsForAllTys
974         : sigtype                       { [ $1 ] }
975         | sigtype ',' sigtypes1         { $1 : $3 }
976
977 -----------------------------------------------------------------------------
978 -- Types
979
980 infixtype :: { LHsType RdrName }
981         : btype qtyconop type         { LL $ mkHsOpTy $1 $2 $3 }
982         | btype tyvarop  type    { LL $ mkHsOpTy $1 $2 $3 }
983
984 strict_mark :: { Located HsBang }
985         : '!'                           { L1 HsStrict }
986         | '{-# UNPACK' '#-}' '!'        { LL HsUnpack }
987         | '{-# NOUNPACK' '#-}' '!'      { LL HsNoUnpack }
988
989 -- A ctype is a for-all type
990 ctype   :: { LHsType RdrName }
991         : 'forall' tv_bndrs '.' ctype   { LL $ mkExplicitHsForAllTy $2 (noLoc []) $4 }
992         | context '=>' ctype            { LL $ mkImplicitHsForAllTy   $1 $3 }
993         -- A type of form (context => type) is an *implicit* HsForAllTy
994         | ipvar '::' type               { LL (HsIParamTy (unLoc $1) $3) }
995         | type                          { $1 }
996
997 ----------------------
998 -- Notes for 'ctypedoc'
999 -- It would have been nice to simplify the grammar by unifying `ctype` and 
1000 -- ctypedoc` into one production, allowing comments on types everywhere (and
1001 -- rejecting them after parsing, where necessary).  This is however not possible
1002 -- since it leads to ambiguity. The reason is the support for comments on record
1003 -- fields: 
1004 --         data R = R { field :: Int -- ^ comment on the field }
1005 -- If we allow comments on types here, it's not clear if the comment applies
1006 -- to 'field' or to 'Int'. So we must use `ctype` to describe the type.
1007
1008 ctypedoc :: { LHsType RdrName }
1009         : 'forall' tv_bndrs '.' ctypedoc        { LL $ mkExplicitHsForAllTy $2 (noLoc []) $4 }
1010         | context '=>' ctypedoc         { LL $ mkImplicitHsForAllTy   $1 $3 }
1011         -- A type of form (context => type) is an *implicit* HsForAllTy
1012         | ipvar '::' type               { LL (HsIParamTy (unLoc $1) $3) }
1013         | typedoc                       { $1 }
1014
1015 ----------------------
1016 -- Notes for 'context'
1017 -- We parse a context as a btype so that we don't get reduce/reduce
1018 -- errors in ctype.  The basic problem is that
1019 --      (Eq a, Ord a)
1020 -- looks so much like a tuple type.  We can't tell until we find the =>
1021
1022 -- We have the t1 ~ t2 form both in 'context' and in type, 
1023 -- to permit an individual equational constraint without parenthesis.
1024 -- Thus for some reason we allow    f :: a~b => blah
1025 -- but not                          f :: ?x::Int => blah
1026 context :: { LHsContext RdrName }
1027         : btype '~'      btype          {% checkContext
1028                                              (LL $ HsEqTy $1 $3) }
1029         | btype                         {% checkContext $1 }
1030
1031 type :: { LHsType RdrName }
1032         : btype                         { $1 }
1033         | btype qtyconop type           { LL $ mkHsOpTy $1 $2 $3 }
1034         | btype tyvarop  type           { LL $ mkHsOpTy $1 $2 $3 }
1035         | btype '->'     ctype          { LL $ HsFunTy $1 $3 }
1036         | btype '~'      btype          { LL $ HsEqTy $1 $3 }
1037                                         -- see Note [Promotion]
1038         | btype SIMPLEQUOTE qconop type     { LL $ mkHsOpTy $1 $3 $4 }
1039         | btype SIMPLEQUOTE varop  type     { LL $ mkHsOpTy $1 $3 $4 }
1040
1041 typedoc :: { LHsType RdrName }
1042         : btype                          { $1 }
1043         | btype docprev                  { LL $ HsDocTy $1 $2 }
1044         | btype qtyconop type            { LL $ mkHsOpTy $1 $2 $3 }
1045         | btype qtyconop type docprev    { LL $ HsDocTy (L (comb3 $1 $2 $3) (mkHsOpTy $1 $2 $3)) $4 }
1046         | btype tyvarop  type            { LL $ mkHsOpTy $1 $2 $3 }
1047         | btype tyvarop  type docprev    { LL $ HsDocTy (L (comb3 $1 $2 $3) (mkHsOpTy $1 $2 $3)) $4 }
1048         | btype '->'     ctypedoc        { LL $ HsFunTy $1 $3 }
1049         | btype docprev '->' ctypedoc    { LL $ HsFunTy (L (comb2 $1 $2) (HsDocTy $1 $2)) $4 }
1050         | btype '~'      btype           { LL $ HsEqTy $1 $3 }
1051
1052 btype :: { LHsType RdrName }
1053         : btype atype                   { LL $ HsAppTy $1 $2 }
1054         | atype                         { $1 }
1055
1056 atype :: { LHsType RdrName }
1057         : ntgtycon                       { L1 (HsTyVar (unLoc $1)) }      -- Not including unit tuples
1058         | tyvar                          { L1 (HsTyVar (unLoc $1)) }      -- (See Note [Unit tuples])
1059         | strict_mark atype              { LL (HsBangTy (unLoc $1) $2) }  -- Constructor sigs only
1060         | '{' fielddecls '}'             {% checkRecordSyntax (LL $ HsRecTy $2) } -- Constructor sigs only
1061         | '(' ')'                        { LL $ HsTupleTy HsBoxedOrConstraintTuple []      }
1062         | '(' ctype ',' comma_types1 ')' { LL $ HsTupleTy HsBoxedOrConstraintTuple ($2:$4) }
1063         | '(#' '#)'                      { LL $ HsTupleTy HsUnboxedTuple           []      }       
1064         | '(#' comma_types1 '#)'         { LL $ HsTupleTy HsUnboxedTuple           $2      }
1065         | '[' ctype ']'                  { LL $ HsListTy  $2 }
1066         | '[:' ctype ':]'                { LL $ HsPArrTy  $2 }
1067         | '(' ctype ')'                  { LL $ HsParTy   $2 }
1068         | '(' ctype '::' kind ')'        { LL $ HsKindSig $2 $4 }
1069         | quasiquote                     { L1 (HsQuasiQuoteTy (unLoc $1)) }
1070         | '$(' exp ')'                   { LL $ mkHsSpliceTy $2 }
1071         | TH_ID_SPLICE                   { LL $ mkHsSpliceTy $ L1 $ HsVar $
1072                                            mkUnqual varName (getTH_ID_SPLICE $1) }
1073                                                       -- see Note [Promotion] for the followings
1074         | SIMPLEQUOTE qconid                          { LL $ HsTyVar $ unLoc $2 }
1075         | SIMPLEQUOTE  '(' ')'                        { LL $ HsTyVar $ getRdrName unitDataCon }
1076         | SIMPLEQUOTE  '(' ctype ',' comma_types1 ')' { LL $ HsExplicitTupleTy [] ($3 : $5) }
1077         | SIMPLEQUOTE  '[' comma_types0 ']'           { LL $ HsExplicitListTy placeHolderKind $3 }
1078         | '[' ctype ',' comma_types1 ']'              { LL $ HsExplicitListTy placeHolderKind ($2 : $4) }
1079         | INTEGER            { LL $ HsTyLit $ HsNumTy $ getINTEGER $1 }
1080         | STRING             { LL $ HsTyLit $ HsStrTy $ getSTRING  $1 }
1081
1082 -- An inst_type is what occurs in the head of an instance decl
1083 --      e.g.  (Foo a, Gaz b) => Wibble a b
1084 -- It's kept as a single type, with a MonoDictTy at the right
1085 -- hand corner, for convenience.
1086 inst_type :: { LHsType RdrName }
1087         : sigtype                       { $1 }
1088
1089 inst_types1 :: { [LHsType RdrName] }
1090         : inst_type                     { [$1] }
1091         | inst_type ',' inst_types1     { $1 : $3 }
1092
1093 comma_types0  :: { [LHsType RdrName] }
1094         : comma_types1                  { $1 }
1095         | {- empty -}                   { [] }
1096
1097 comma_types1    :: { [LHsType RdrName] }
1098         : ctype                         { [$1] }
1099         | ctype  ',' comma_types1       { $1 : $3 }
1100
1101 tv_bndrs :: { [LHsTyVarBndr RdrName] }
1102          : tv_bndr tv_bndrs             { $1 : $2 }
1103          | {- empty -}                  { [] }
1104
1105 tv_bndr :: { LHsTyVarBndr RdrName }
1106         : tyvar                         { L1 (UserTyVar (unLoc $1) placeHolderKind) }
1107         | '(' tyvar '::' kind ')'       { LL (KindedTyVar (unLoc $2) $4 placeHolderKind) }
1108
1109 fds :: { Located [Located (FunDep RdrName)] }
1110         : {- empty -}                   { noLoc [] }
1111         | '|' fds1                      { LL (reverse (unLoc $2)) }
1112
1113 fds1 :: { Located [Located (FunDep RdrName)] }
1114         : fds1 ',' fd                   { LL ($3 : unLoc $1) }
1115         | fd                            { L1 [$1] }
1116
1117 fd :: { Located (FunDep RdrName) }
1118         : varids0 '->' varids0          { L (comb3 $1 $2 $3)
1119                                            (reverse (unLoc $1), reverse (unLoc $3)) }
1120
1121 varids0 :: { Located [RdrName] }
1122         : {- empty -}                   { noLoc [] }
1123         | varids0 tyvar                 { LL (unLoc $2 : unLoc $1) }
1124
1125 -----------------------------------------------------------------------------
1126 -- Kinds
1127
1128 kind :: { LHsKind RdrName }
1129         : bkind                  { $1 }
1130         | bkind '->' kind        { LL $ HsFunTy $1 $3 }
1131
1132 bkind :: { LHsKind RdrName }
1133         : akind                  { $1 }
1134         | bkind akind            { LL $ HsAppTy $1 $2 }
1135
1136 akind :: { LHsKind RdrName }
1137         : '*'                    { L1 $ HsTyVar (nameRdrName liftedTypeKindTyConName) }
1138         | '(' kind ')'           { LL $ HsParTy $2 }
1139         | pkind                  { $1 }
1140
1141 pkind :: { LHsKind RdrName }  -- promoted type, see Note [Promotion]
1142         : qtycon                          { L1 $ HsTyVar $ unLoc $1 }
1143         | '(' ')'                         { LL $ HsTyVar $ getRdrName unitTyCon }
1144         | '(' kind ',' comma_kinds1 ')'   { LL $ HsTupleTy HsBoxedTuple ($2 : $4) }
1145         | '[' kind ']'                    { LL $ HsListTy $2 }
1146
1147 comma_kinds1 :: { [LHsKind RdrName] }
1148         : kind                          { [$1] }
1149         | kind  ',' comma_kinds1        { $1 : $3 }
1150
1151 {- Note [Promotion]
1152    ~~~~~~~~~~~~~~~~
1153
1154 - Syntax of promoted qualified names
1155 We write 'Nat.Zero instead of Nat.'Zero when dealing with qualified
1156 names. Moreover ticks are only allowed in types, not in kinds, for a
1157 few reasons:
1158   1. we don't need quotes since we cannot define names in kinds
1159   2. if one day we merge types and kinds, tick would mean look in DataName
1160   3. we don't have a kind namespace anyway
1161
1162 - Syntax of explicit kind polymorphism  (IA0_TODO: not yet implemented)
1163 Kind abstraction is implicit. We write
1164 > data SList (s :: k -> *) (as :: [k]) where ...
1165 because it looks like what we do in terms
1166 > id (x :: a) = x
1167
1168 - Name resolution
1169 When the user write Zero instead of 'Zero in types, we parse it a
1170 HsTyVar ("Zero", TcClsName) instead of HsTyVar ("Zero", DataName). We
1171 deal with this in the renamer. If a HsTyVar ("Zero", TcClsName) is not
1172 bounded in the type level, then we look for it in the term level (we
1173 change its namespace to DataName, see Note [Demotion] in OccName). And
1174 both become a HsTyVar ("Zero", DataName) after the renamer.
1175
1176 -}
1177
1178
1179 -----------------------------------------------------------------------------
1180 -- Datatype declarations
1181
1182 gadt_constrlist :: { Located [LConDecl RdrName] }       -- Returned in order
1183         : 'where' '{'        gadt_constrs '}'      { L (comb2 $1 $3) (unLoc $3) }
1184         | 'where' vocurly    gadt_constrs close    { L (comb2 $1 $3) (unLoc $3) }
1185         | {- empty -}                              { noLoc [] }
1186
1187 gadt_constrs :: { Located [LConDecl RdrName] }
1188         : gadt_constr ';' gadt_constrs  { L (comb2 (head $1) $3) ($1 ++ unLoc $3) }
1189         | gadt_constr                   { L (getLoc (head $1)) $1 }
1190         | {- empty -}                   { noLoc [] }
1191
1192 -- We allow the following forms:
1193 --      C :: Eq a => a -> T a
1194 --      C :: forall a. Eq a => !a -> T a
1195 --      D { x,y :: a } :: T a
1196 --      forall a. Eq a => D { x,y :: a } :: T a
1197
1198 gadt_constr :: { [LConDecl RdrName] }   -- Returns a list because of:   C,D :: ty
1199         : con_list '::' sigtype
1200                 { map (sL (comb2 $1 $3)) (mkGadtDecl (unLoc $1) $3) } 
1201
1202                 -- Deprecated syntax for GADT record declarations
1203         | oqtycon '{' fielddecls '}' '::' sigtype
1204                 {% do { cd <- mkDeprecatedGadtRecordDecl (comb2 $1 $6) $1 $3 $6
1205                       ; cd' <- checkRecordSyntax cd
1206                       ; return [cd'] } }
1207
1208 constrs :: { Located [LConDecl RdrName] }
1209         : maybe_docnext '=' constrs1    { L (comb2 $2 $3) (addConDocs (unLoc $3) $1) }
1210
1211 constrs1 :: { Located [LConDecl RdrName] }
1212         : constrs1 maybe_docnext '|' maybe_docprev constr { LL (addConDoc $5 $2 : addConDocFirst (unLoc $1) $4) }
1213         | constr                                          { L1 [$1] }
1214
1215 constr :: { LConDecl RdrName }
1216         : maybe_docnext forall context '=>' constr_stuff maybe_docprev  
1217                 { let (con,details) = unLoc $5 in 
1218                   addConDoc (L (comb4 $2 $3 $4 $5) (mkSimpleConDecl con (unLoc $2) $3 details))
1219                             ($1 `mplus` $6) }
1220         | maybe_docnext forall constr_stuff maybe_docprev
1221                 { let (con,details) = unLoc $3 in 
1222                   addConDoc (L (comb2 $2 $3) (mkSimpleConDecl con (unLoc $2) (noLoc []) details))
1223                             ($1 `mplus` $4) }
1224
1225 forall :: { Located [LHsTyVarBndr RdrName] }
1226         : 'forall' tv_bndrs '.'         { LL $2 }
1227         | {- empty -}                   { noLoc [] }
1228
1229 constr_stuff :: { Located (Located RdrName, HsConDeclDetails RdrName) }
1230 -- We parse the constructor declaration 
1231 --      C t1 t2
1232 -- as a btype (treating C as a type constructor) and then convert C to be
1233 -- a data constructor.  Reason: it might continue like this:
1234 --      C t1 t2 %: D Int
1235 -- in which case C really would be a type constructor.  We can't resolve this
1236 -- ambiguity till we come across the constructor oprerator :% (or not, more usually)
1237         : btype                         {% splitCon $1 >>= return.LL }
1238         | btype conop btype             {  LL ($2, InfixCon $1 $3) }
1239
1240 fielddecls :: { [ConDeclField RdrName] }
1241         : {- empty -}     { [] }
1242         | fielddecls1     { $1 }
1243
1244 fielddecls1 :: { [ConDeclField RdrName] }
1245         : fielddecl maybe_docnext ',' maybe_docprev fielddecls1
1246                       { [ addFieldDoc f $4 | f <- $1 ] ++ addFieldDocs $5 $2 }
1247                              -- This adds the doc $4 to each field separately
1248         | fielddecl   { $1 }
1249
1250 fielddecl :: { [ConDeclField RdrName] }    -- A list because of   f,g :: Int
1251         : maybe_docnext sig_vars '::' ctype maybe_docprev      { [ ConDeclField fld $4 ($1 `mplus` $5) 
1252                                                                  | fld <- reverse (unLoc $2) ] }
1253
1254 -- We allow the odd-looking 'inst_type' in a deriving clause, so that
1255 -- we can do deriving( forall a. C [a] ) in a newtype (GHC extension).
1256 -- The 'C [a]' part is converted to an HsPredTy by checkInstType
1257 -- We don't allow a context, but that's sorted out by the type checker.
1258 deriving :: { Located (Maybe [LHsType RdrName]) }
1259         : {- empty -}                           { noLoc Nothing }
1260         | 'deriving' qtycon                     { let { L loc tv = $2 }
1261                                                   in LL (Just [L loc (HsTyVar tv)]) } 
1262         | 'deriving' '(' ')'                    { LL (Just []) }
1263         | 'deriving' '(' inst_types1 ')'        { LL (Just $3) }
1264              -- Glasgow extension: allow partial 
1265              -- applications in derivings
1266
1267 -----------------------------------------------------------------------------
1268 -- Value definitions
1269
1270 {- Note [Declaration/signature overlap]
1271 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
1272 There's an awkward overlap with a type signature.  Consider
1273         f :: Int -> Int = ...rhs...
1274    Then we can't tell whether it's a type signature or a value
1275    definition with a result signature until we see the '='.
1276    So we have to inline enough to postpone reductions until we know.
1277 -}
1278
1279 {-
1280   ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var
1281   instead of qvar, we get another shift/reduce-conflict. Consider the
1282   following programs:
1283   
1284      { (^^) :: Int->Int ; }          Type signature; only var allowed
1285
1286      { (^^) :: Int->Int = ... ; }    Value defn with result signature;
1287                                      qvar allowed (because of instance decls)
1288   
1289   We can't tell whether to reduce var to qvar until after we've read the signatures.
1290 -}
1291
1292 docdecl :: { LHsDecl RdrName }
1293         : docdecld { L1 (DocD (unLoc $1)) }
1294
1295 docdecld :: { LDocDecl }
1296         : docnext                               { L1 (DocCommentNext (unLoc $1)) }
1297         | docprev                               { L1 (DocCommentPrev (unLoc $1)) }
1298         | docnamed                              { L1 (case (unLoc $1) of (n, doc) -> DocCommentNamed n doc) }
1299         | docsection                            { L1 (case (unLoc $1) of (n, doc) -> DocGroup n doc) }
1300
1301 decl    :: { Located (OrdList (LHsDecl RdrName)) }
1302         : sigdecl               { $1 }
1303
1304         | '!' aexp rhs          {% do { let { e = LL (SectionR (LL (HsVar bang_RDR)) $2) };
1305                                         pat <- checkPattern e;
1306                                         return $ LL $ unitOL $ LL $ ValD $
1307                                                PatBind pat (unLoc $3)
1308                                                        placeHolderType placeHolderNames (Nothing,[]) } }
1309                                 -- Turn it all into an expression so that
1310                                 -- checkPattern can check that bangs are enabled
1311
1312         | infixexp opt_sig rhs  {% do { r <- checkValDef $1 $2 $3;
1313                                         let { l = comb2 $1 $> };
1314                                         return $! (sL l (unitOL $! (sL l $ ValD r))) } }
1315         | docdecl               { LL $ unitOL $1 }
1316
1317 rhs     :: { Located (GRHSs RdrName) }
1318         : '=' exp wherebinds    { sL (comb3 $1 $2 $3) $ GRHSs (unguardedRHS $2) (unLoc $3) }
1319         | gdrhs wherebinds      { LL $ GRHSs (reverse (unLoc $1)) (unLoc $2) }
1320
1321 gdrhs :: { Located [LGRHS RdrName] }
1322         : gdrhs gdrh            { LL ($2 : unLoc $1) }
1323         | gdrh                  { L1 [$1] }
1324
1325 gdrh :: { LGRHS RdrName }
1326         : '|' guardquals '=' exp        { sL (comb2 $1 $>) $ GRHS (unLoc $2) $4 }
1327
1328 sigdecl :: { Located (OrdList (LHsDecl RdrName)) }
1329         : 
1330         -- See Note [Declaration/signature overlap] for why we need infixexp here
1331           infixexp '::' sigtypedoc
1332                         {% do s <- checkValSig $1 $3 
1333                         ; return (LL $ unitOL (LL $ SigD s)) }
1334         | var ',' sig_vars '::' sigtypedoc
1335                                 { LL $ toOL [ LL $ SigD (TypeSig ($1 : unLoc $3) $5) ] }
1336         | infix prec ops        { LL $ toOL [ LL $ SigD (FixSig (FixitySig n (Fixity $2 (unLoc $1))))
1337                                              | n <- unLoc $3 ] }
1338         | '{-# INLINE' activation qvar '#-}'        
1339                 { LL $ unitOL (LL $ SigD (InlineSig $3 (mkInlinePragma (getINLINE $1) $2))) }
1340         | '{-# SPECIALISE' activation qvar '::' sigtypes1 '#-}'
1341                 { let inl_prag = mkInlinePragma (EmptyInlineSpec, FunLike) $2
1342                   in LL $ toOL [ LL $ SigD (SpecSig $3 t inl_prag) 
1343                                | t <- $5] }
1344         | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes1 '#-}'
1345                 { LL $ toOL [ LL $ SigD (SpecSig $3 t (mkInlinePragma (getSPEC_INLINE $1) $2))
1346                             | t <- $5] }
1347         | '{-# SPECIALISE' 'instance' inst_type '#-}'
1348                 { LL $ unitOL (LL $ SigD (SpecInstSig $3)) }
1349
1350 -----------------------------------------------------------------------------
1351 -- Expressions
1352
1353 quasiquote :: { Located (HsQuasiQuote RdrName) }
1354         : TH_QUASIQUOTE   { let { loc = getLoc $1
1355                                 ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc $1
1356                                 ; quoterId = mkUnqual varName quoter }
1357                             in L1 (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote) }
1358
1359 exp   :: { LHsExpr RdrName }
1360         : infixexp '::' sigtype         { LL $ ExprWithTySig $1 $3 }
1361         | infixexp '-<' exp             { LL $ HsArrApp $1 $3 placeHolderType HsFirstOrderApp True }
1362         | infixexp '>-' exp             { LL $ HsArrApp $3 $1 placeHolderType HsFirstOrderApp False }
1363         | infixexp '-<<' exp            { LL $ HsArrApp $1 $3 placeHolderType HsHigherOrderApp True }
1364         | infixexp '>>-' exp            { LL $ HsArrApp $3 $1 placeHolderType HsHigherOrderApp False}
1365         | infixexp                      { $1 }
1366
1367 infixexp :: { LHsExpr RdrName }
1368         : exp10                         { $1 }
1369         | infixexp qop exp10            { LL (OpApp $1 $2 (panic "fixity") $3) }
1370
1371 exp10 :: { LHsExpr RdrName }
1372         : '\\' apat apats opt_asig '->' exp     
1373                         { LL $ HsLam (mkMatchGroup [LL $ Match ($2:$3) $4
1374                                                                 (unguardedGRHSs $6)
1375                                                             ]) }
1376         | 'let' binds 'in' exp                  { LL $ HsLet (unLoc $2) $4 }
1377         | 'if' exp optSemi 'then' exp optSemi 'else' exp
1378                                         {% checkDoAndIfThenElse $2 $3 $5 $6 $8 >>
1379                                            return (LL $ mkHsIf $2 $5 $8) }
1380         | 'case' exp 'of' altslist              { LL $ HsCase $2 (mkMatchGroup (unLoc $4)) }
1381         | '-' fexp                              { LL $ NegApp $2 noSyntaxExpr }
1382
1383         | 'do' stmtlist                 { L (comb2 $1 $2) (mkHsDo DoExpr  (unLoc $2)) }
1384         | 'mdo' stmtlist                { L (comb2 $1 $2) (mkHsDo MDoExpr (unLoc $2)) }
1385
1386         | scc_annot exp                         { LL $ if opt_SccProfilingOn
1387                                                         then HsSCC (unLoc $1) $2
1388                                                         else HsPar $2 }
1389         | hpc_annot exp                         { LL $ if opt_Hpc
1390                                                         then HsTickPragma (unLoc $1) $2
1391                                                         else HsPar $2 }
1392
1393         | 'proc' aexp '->' exp  
1394                         {% checkPattern $2 >>= \ p -> 
1395                            return (LL $ HsProc p (LL $ HsCmdTop $4 [] 
1396                                                    placeHolderType undefined)) }
1397                                                 -- TODO: is LL right here?
1398
1399         | '{-# CORE' STRING '#-}' exp           { LL $ HsCoreAnn (getSTRING $2) $4 }
1400                                                     -- hdaume: core annotation
1401         | fexp                                  { $1 }
1402
1403 optSemi :: { Bool }
1404         : ';'         { True }
1405         | {- empty -} { False }
1406
1407 scc_annot :: { Located FastString }
1408         : '_scc_' STRING                        {% (addWarning Opt_WarnWarningsDeprecations (getLoc $1) (text "_scc_ is deprecated; use an SCC pragma instead")) >>= \_ ->
1409                                    ( do scc <- getSCC $2; return $ LL scc ) }
1410         | '{-# SCC' STRING '#-}'                {% do scc <- getSCC $2; return $ LL scc }
1411         | '{-# SCC' VARID  '#-}'                { LL (getVARID $2) }
1412
1413 hpc_annot :: { Located (FastString,(Int,Int),(Int,Int)) }
1414         : '{-# GENERATED' STRING INTEGER ':' INTEGER '-' INTEGER ':' INTEGER '#-}'
1415                                                 { LL $ (getSTRING $2
1416                                                        ,( fromInteger $ getINTEGER $3
1417                                                         , fromInteger $ getINTEGER $5
1418                                                         )
1419                                                        ,( fromInteger $ getINTEGER $7
1420                                                         , fromInteger $ getINTEGER $9
1421                                                         )
1422                                                        )
1423                                                  }
1424
1425 fexp    :: { LHsExpr RdrName }
1426         : fexp aexp                             { LL $ HsApp $1 $2 }
1427         | aexp                                  { $1 }
1428
1429 aexp    :: { LHsExpr RdrName }
1430         : qvar '@' aexp                 { LL $ EAsPat $1 $3 }
1431         | '~' aexp                      { LL $ ELazyPat $2 }
1432         | aexp1                 { $1 }
1433
1434 aexp1   :: { LHsExpr RdrName }
1435         : aexp1 '{' fbinds '}'  {% do { r <- mkRecConstrOrUpdate $1 (comb2 $2 $4) $3
1436                                       ; checkRecordSyntax (LL r) }}
1437         | aexp2                 { $1 }
1438
1439 aexp2   :: { LHsExpr RdrName }
1440         : ipvar                         { L1 (HsIPVar $! unLoc $1) }
1441         | qcname                        { L1 (HsVar   $! unLoc $1) }
1442         | literal                       { L1 (HsLit   $! unLoc $1) }
1443 -- This will enable overloaded strings permanently.  Normally the renamer turns HsString
1444 -- into HsOverLit when -foverloaded-strings is on.
1445 --      | STRING                        { sL (getLoc $1) (HsOverLit $! mkHsIsString (getSTRING $1) placeHolderType) }
1446         | INTEGER                       { sL (getLoc $1) (HsOverLit $! mkHsIntegral (getINTEGER $1) placeHolderType) }
1447         | RATIONAL                      { sL (getLoc $1) (HsOverLit $! mkHsFractional (getRATIONAL $1) placeHolderType) }
1448
1449         -- N.B.: sections get parsed by these next two productions.
1450         -- This allows you to write, e.g., '(+ 3, 4 -)', which isn't
1451         -- correct Haskell (you'd have to write '((+ 3), (4 -))')
1452         -- but the less cluttered version fell out of having texps.
1453         | '(' texp ')'                  { LL (HsPar $2) }
1454         | '(' tup_exprs ')'             { LL (ExplicitTuple $2 Boxed) }
1455
1456         | '(#' texp '#)'                { LL (ExplicitTuple [Present $2] Unboxed) }
1457         | '(#' tup_exprs '#)'           { LL (ExplicitTuple $2 Unboxed) }
1458
1459         | '[' list ']'                  { LL (unLoc $2) }
1460         | '[:' parr ':]'                { LL (unLoc $2) }
1461         | '_'                           { L1 EWildPat }
1462         
1463         -- Template Haskell Extension
1464         | TH_ID_SPLICE          { L1 $ HsSpliceE (mkHsSplice 
1465                                         (L1 $ HsVar (mkUnqual varName 
1466                                                         (getTH_ID_SPLICE $1)))) } 
1467         | '$(' exp ')'          { LL $ HsSpliceE (mkHsSplice $2) }               
1468
1469
1470         | SIMPLEQUOTE  qvar     { LL $ HsBracket (VarBr True  (unLoc $2)) }
1471         | SIMPLEQUOTE  qcon     { LL $ HsBracket (VarBr True  (unLoc $2)) }
1472         | TH_TY_QUOTE tyvar     { LL $ HsBracket (VarBr False (unLoc $2)) }
1473         | TH_TY_QUOTE gtycon    { LL $ HsBracket (VarBr False (unLoc $2)) }
1474         | '[|' exp '|]'         { LL $ HsBracket (ExpBr $2) }                       
1475         | '[t|' ctype '|]'      { LL $ HsBracket (TypBr $2) }                       
1476         | '[p|' infixexp '|]'   {% checkPattern $2 >>= \p ->
1477                                         return (LL $ HsBracket (PatBr p)) }
1478         | '[d|' cvtopbody '|]'  { LL $ HsBracket (DecBrL $2) }
1479         | quasiquote            { L1 (HsQuasiQuoteE (unLoc $1)) }
1480
1481         -- arrow notation extension
1482         | '(|' aexp2 cmdargs '|)'       { LL $ HsArrForm $2 Nothing (reverse $3) }
1483
1484 cmdargs :: { [LHsCmdTop RdrName] }
1485         : cmdargs acmd                  { $2 : $1 }
1486         | {- empty -}                   { [] }
1487
1488 acmd    :: { LHsCmdTop RdrName }
1489         : aexp2                 { L1 $ HsCmdTop $1 [] placeHolderType undefined }
1490
1491 cvtopbody :: { [LHsDecl RdrName] }
1492         :  '{'            cvtopdecls0 '}'               { $2 }
1493         |      vocurly    cvtopdecls0 close             { $2 }
1494
1495 cvtopdecls0 :: { [LHsDecl RdrName] }
1496         : {- empty -}           { [] }
1497         | cvtopdecls            { $1 }
1498
1499 -----------------------------------------------------------------------------
1500 -- Tuple expressions
1501
1502 -- "texp" is short for tuple expressions: 
1503 -- things that can appear unparenthesized as long as they're
1504 -- inside parens or delimitted by commas
1505 texp :: { LHsExpr RdrName }
1506         : exp                           { $1 }
1507
1508         -- Note [Parsing sections]
1509         -- ~~~~~~~~~~~~~~~~~~~~~~~
1510         -- We include left and right sections here, which isn't
1511         -- technically right according to the Haskell standard.
1512         -- For example (3 +, True) isn't legal.
1513         -- However, we want to parse bang patterns like
1514         --      (!x, !y)
1515         -- and it's convenient to do so here as a section
1516         -- Then when converting expr to pattern we unravel it again
1517         -- Meanwhile, the renamer checks that real sections appear
1518         -- inside parens.
1519         | infixexp qop        { LL $ SectionL $1 $2 }
1520         | qopm infixexp       { LL $ SectionR $1 $2 }
1521
1522        -- View patterns get parenthesized above
1523         | exp '->' texp   { LL $ EViewPat $1 $3 }
1524
1525 -- Always at least one comma
1526 tup_exprs :: { [HsTupArg RdrName] }
1527            : texp commas_tup_tail  { Present $1 : $2 }
1528            | commas tup_tail       { replicate $1 missingTupArg ++ $2 }
1529
1530 -- Always starts with commas; always follows an expr
1531 commas_tup_tail :: { [HsTupArg RdrName] }
1532 commas_tup_tail : commas tup_tail  { replicate ($1-1) missingTupArg ++ $2 }
1533
1534 -- Always follows a comma
1535 tup_tail :: { [HsTupArg RdrName] }
1536           : texp commas_tup_tail        { Present $1 : $2 }
1537           | texp                        { [Present $1] }
1538           | {- empty -}                 { [missingTupArg] }
1539
1540 -----------------------------------------------------------------------------
1541 -- List expressions
1542
1543 -- The rules below are little bit contorted to keep lexps left-recursive while
1544 -- avoiding another shift/reduce-conflict.
1545
1546 list :: { LHsExpr RdrName }
1547         : texp                  { L1 $ ExplicitList placeHolderType [$1] }
1548         | lexps                 { L1 $ ExplicitList placeHolderType (reverse (unLoc $1)) }
1549         | texp '..'             { LL $ ArithSeq noPostTcExpr (From $1) }
1550         | texp ',' exp '..'     { LL $ ArithSeq noPostTcExpr (FromThen $1 $3) }
1551         | texp '..' exp         { LL $ ArithSeq noPostTcExpr (FromTo $1 $3) }
1552         | texp ',' exp '..' exp { LL $ ArithSeq noPostTcExpr (FromThenTo $1 $3 $5) }
1553         | texp '|' flattenedpquals      
1554              {% checkMonadComp >>= \ ctxt ->
1555                 return (sL (comb2 $1 $>) $ 
1556                         mkHsComp ctxt (unLoc $3) $1) }
1557
1558 lexps :: { Located [LHsExpr RdrName] }
1559         : lexps ',' texp                { LL (((:) $! $3) $! unLoc $1) }
1560         | texp ',' texp                 { LL [$3,$1] }
1561
1562 -----------------------------------------------------------------------------
1563 -- List Comprehensions
1564
1565 flattenedpquals :: { Located [LStmt RdrName] }
1566     : pquals   { case (unLoc $1) of
1567                     [qs] -> L1 qs
1568                     -- We just had one thing in our "parallel" list so 
1569                     -- we simply return that thing directly
1570                     
1571                     qss -> L1 [L1 $ ParStmt [(qs, undefined) | qs <- qss] noSyntaxExpr noSyntaxExpr noSyntaxExpr]
1572                     -- We actually found some actual parallel lists so
1573                     -- we wrap them into as a ParStmt
1574                 }
1575
1576 pquals :: { Located [[LStmt RdrName]] }
1577     : squals '|' pquals     { L (getLoc $2) (reverse (unLoc $1) : unLoc $3) }
1578     | squals                { L (getLoc $1) [reverse (unLoc $1)] }
1579
1580 squals :: { Located [LStmt RdrName] }   -- In reverse order, because the last 
1581                                         -- one can "grab" the earlier ones
1582     : squals ',' transformqual               { LL [L (getLoc $3) ((unLoc $3) (reverse (unLoc $1)))] }
1583     | squals ',' qual                        { LL ($3 : unLoc $1) }
1584     | transformqual                          { LL [L (getLoc $1) ((unLoc $1) [])] }
1585     | qual                                   { L1 [$1] }
1586 --  | transformquals1 ',' '{|' pquals '|}'   { LL ($4 : unLoc $1) }
1587 --  | '{|' pquals '|}'                       { L1 [$2] }
1588
1589
1590 -- It is possible to enable bracketing (associating) qualifier lists
1591 -- by uncommenting the lines with {| |} above. Due to a lack of
1592 -- consensus on the syntax, this feature is not being used until we
1593 -- get user demand.
1594
1595 transformqual :: { Located ([LStmt RdrName] -> Stmt RdrName) }
1596                         -- Function is applied to a list of stmts *in order*
1597     : 'then' exp                           { LL $ \ss -> (mkTransformStmt    ss $2)    }
1598     | 'then' exp 'by' exp                  { LL $ \ss -> (mkTransformByStmt  ss $2 $4) }
1599     | 'then' 'group' 'using' exp           { LL $ \ss -> (mkGroupUsingStmt   ss $4)    }
1600     | 'then' 'group' 'by' exp 'using' exp  { LL $ \ss -> (mkGroupByUsingStmt ss $4 $6) }
1601
1602 -- Note that 'group' is a special_id, which means that you can enable
1603 -- TransformListComp while still using Data.List.group. However, this
1604 -- introduces a shift/reduce conflict. Happy chooses to resolve the conflict
1605 -- in by choosing the "group by" variant, which is what we want.
1606
1607 -----------------------------------------------------------------------------
1608 -- Parallel array expressions
1609
1610 -- The rules below are little bit contorted; see the list case for details.
1611 -- Note that, in contrast to lists, we only have finite arithmetic sequences.
1612 -- Moreover, we allow explicit arrays with no element (represented by the nil
1613 -- constructor in the list case).
1614
1615 parr :: { LHsExpr RdrName }
1616         :                               { noLoc (ExplicitPArr placeHolderType []) }
1617         | texp                          { L1 $ ExplicitPArr placeHolderType [$1] }
1618         | lexps                         { L1 $ ExplicitPArr placeHolderType 
1619                                                        (reverse (unLoc $1)) }
1620         | texp '..' exp                 { LL $ PArrSeq noPostTcExpr (FromTo $1 $3) }
1621         | texp ',' exp '..' exp         { LL $ PArrSeq noPostTcExpr (FromThenTo $1 $3 $5) }
1622         | texp '|' flattenedpquals      { LL $ mkHsComp PArrComp (unLoc $3) $1 }
1623
1624 -- We are reusing `lexps' and `flattenedpquals' from the list case.
1625
1626 -----------------------------------------------------------------------------
1627 -- Guards
1628
1629 guardquals :: { Located [LStmt RdrName] }
1630     : guardquals1           { L (getLoc $1) (reverse (unLoc $1)) }
1631
1632 guardquals1 :: { Located [LStmt RdrName] }
1633     : guardquals1 ',' qual  { LL ($3 : unLoc $1) }
1634     | qual                  { L1 [$1] }
1635
1636 -----------------------------------------------------------------------------
1637 -- Case alternatives
1638
1639 altslist :: { Located [LMatch RdrName] }
1640         : '{'            alts '}'       { LL (reverse (unLoc $2)) }
1641         |     vocurly    alts  close    { L (getLoc $2) (reverse (unLoc $2)) }
1642
1643 alts    :: { Located [LMatch RdrName] }
1644         : alts1                         { L1 (unLoc $1) }
1645         | ';' alts                      { LL (unLoc $2) }
1646
1647 alts1   :: { Located [LMatch RdrName] }
1648         : alts1 ';' alt                 { LL ($3 : unLoc $1) }
1649         | alts1 ';'                     { LL (unLoc $1) }
1650         | alt                           { L1 [$1] }
1651
1652 alt     :: { LMatch RdrName }
1653         : pat opt_sig alt_rhs           { LL (Match [$1] $2 (unLoc $3)) }
1654
1655 alt_rhs :: { Located (GRHSs RdrName) }
1656         : ralt wherebinds               { LL (GRHSs (unLoc $1) (unLoc $2)) }
1657
1658 ralt :: { Located [LGRHS RdrName] }
1659         : '->' exp                      { LL (unguardedRHS $2) }
1660         | gdpats                        { L1 (reverse (unLoc $1)) }
1661
1662 gdpats :: { Located [LGRHS RdrName] }
1663         : gdpats gdpat                  { LL ($2 : unLoc $1) }
1664         | gdpat                         { L1 [$1] }
1665
1666 gdpat   :: { LGRHS RdrName }
1667         : '|' guardquals '->' exp               { sL (comb2 $1 $>) $ GRHS (unLoc $2) $4 }
1668
1669 -- 'pat' recognises a pattern, including one with a bang at the top
1670 --      e.g.  "!x" or "!(x,y)" or "C a b" etc
1671 -- Bangs inside are parsed as infix operator applications, so that
1672 -- we parse them right when bang-patterns are off
1673 pat     :: { LPat RdrName }
1674 pat     :  exp                  {% checkPattern $1 }
1675         | '!' aexp              {% checkPattern (LL (SectionR (L1 (HsVar bang_RDR)) $2)) }
1676
1677 apat   :: { LPat RdrName }      
1678 apat    : aexp                  {% checkPattern $1 }
1679         | '!' aexp              {% checkPattern (LL (SectionR (L1 (HsVar bang_RDR)) $2)) }
1680
1681 apats  :: { [LPat RdrName] }
1682         : apat apats            { $1 : $2 }
1683         | {- empty -}           { [] }
1684
1685 -----------------------------------------------------------------------------
1686 -- Statement sequences
1687
1688 stmtlist :: { Located [LStmt RdrName] }
1689         : '{'           stmts '}'       { LL (unLoc $2) }
1690         |     vocurly   stmts close     { $2 }
1691
1692 --      do { ;; s ; s ; ; s ;; }
1693 -- The last Stmt should be an expression, but that's hard to enforce
1694 -- here, because we need too much lookahead if we see do { e ; }
1695 -- So we use ExprStmts throughout, and switch the last one over
1696 -- in ParseUtils.checkDo instead
1697 stmts :: { Located [LStmt RdrName] }
1698         : stmt stmts_help               { LL ($1 : unLoc $2) }
1699         | ';' stmts                     { LL (unLoc $2) }
1700         | {- empty -}                   { noLoc [] }
1701
1702 stmts_help :: { Located [LStmt RdrName] } -- might be empty
1703         : ';' stmts                     { LL (unLoc $2) }
1704         | {- empty -}                   { noLoc [] }
1705
1706 -- For typing stmts at the GHCi prompt, where 
1707 -- the input may consist of just comments.
1708 maybe_stmt :: { Maybe (LStmt RdrName) }
1709         : stmt                          { Just $1 }
1710         | {- nothing -}                 { Nothing }
1711
1712 stmt  :: { LStmt RdrName }
1713         : qual                              { $1 }
1714         | 'rec' stmtlist                { LL $ mkRecStmt (unLoc $2) }
1715
1716 qual  :: { LStmt RdrName }
1717     : pat '<-' exp                      { LL $ mkBindStmt $1 $3 }
1718     | exp                                   { L1 $ mkExprStmt $1 }
1719     | 'let' binds                       { LL $ LetStmt (unLoc $2) }
1720
1721 -----------------------------------------------------------------------------
1722 -- Record Field Update/Construction
1723
1724 fbinds  :: { ([HsRecField RdrName (LHsExpr RdrName)], Bool) }
1725         : fbinds1                       { $1 }
1726         | {- empty -}                   { ([], False) }
1727
1728 fbinds1 :: { ([HsRecField RdrName (LHsExpr RdrName)], Bool) }
1729         : fbind ',' fbinds1             { case $3 of (flds, dd) -> ($1 : flds, dd) } 
1730         | fbind                         { ([$1], False) }
1731         | '..'                          { ([],   True) }
1732   
1733 fbind   :: { HsRecField RdrName (LHsExpr RdrName) }
1734         : qvar '=' exp  { HsRecField $1 $3                False }
1735         | qvar          { HsRecField $1 placeHolderPunRhs True }
1736                         -- In the punning case, use a place-holder
1737                         -- The renamer fills in the final value
1738
1739 -----------------------------------------------------------------------------
1740 -- Implicit Parameter Bindings
1741
1742 dbinds  :: { Located [LIPBind RdrName] }
1743         : dbinds ';' dbind              { let { this = $3; rest = unLoc $1 }
1744                               in rest `seq` this `seq` LL (this : rest) }
1745         | dbinds ';'                    { LL (unLoc $1) }
1746         | dbind                         { let this = $1 in this `seq` L1 [this] }
1747 --      | {- empty -}                   { [] }
1748
1749 dbind   :: { LIPBind RdrName }
1750 dbind   : ipvar '=' exp                 { LL (IPBind (unLoc $1) $3) }
1751
1752 ipvar   :: { Located (IPName RdrName) }
1753         : IPDUPVARID            { L1 (IPName (mkUnqual varName (getIPDUPVARID $1))) }
1754
1755 -----------------------------------------------------------------------------
1756 -- Warnings and deprecations
1757
1758 namelist :: { Located [RdrName] }
1759 namelist : name_var              { L1 [unLoc $1] }
1760          | name_var ',' namelist { LL (unLoc $1 : unLoc $3) }
1761
1762 name_var :: { Located RdrName }
1763 name_var : var { $1 }
1764          | con { $1 }
1765
1766 -----------------------------------------
1767 -- Data constructors
1768 qcon    :: { Located RdrName }
1769         : qconid                { $1 }
1770         | '(' qconsym ')'       { LL (unLoc $2) }
1771         | sysdcon               { L1 $ nameRdrName (dataConName (unLoc $1)) }
1772 -- The case of '[:' ':]' is part of the production `parr'
1773
1774 con     :: { Located RdrName }
1775         : conid                 { $1 }
1776         | '(' consym ')'        { LL (unLoc $2) }
1777         | sysdcon               { L1 $ nameRdrName (dataConName (unLoc $1)) }
1778
1779 con_list :: { Located [Located RdrName] }
1780 con_list : con                  { L1 [$1] }
1781          | con ',' con_list     { LL ($1 : unLoc $3) }
1782
1783 sysdcon :: { Located DataCon }  -- Wired in data constructors
1784         : '(' ')'               { LL unitDataCon }
1785         | '(' commas ')'        { LL $ tupleCon BoxedTuple ($2 + 1) }
1786         | '(#' '#)'             { LL $ unboxedUnitDataCon }
1787         | '(#' commas '#)'      { LL $ tupleCon UnboxedTuple ($2 + 1) }
1788         | '[' ']'               { LL nilDataCon }
1789
1790 conop :: { Located RdrName }
1791         : consym                { $1 }  
1792         | '`' conid '`'         { LL (unLoc $2) }
1793
1794 qconop :: { Located RdrName }
1795         : qconsym               { $1 }
1796         | '`' qconid '`'        { LL (unLoc $2) }
1797
1798 ----------------------------------------------------------------------------
1799 -- Type constructors
1800
1801
1802 -- See Note [Unit tuples] in HsTypes for the distinction 
1803 -- between gtycon and ntgtycon
1804 gtycon :: { Located RdrName }  -- A "general" qualified tycon, including unit tuples
1805         : ntgtycon                      { $1 }
1806         | '(' ')'                       { LL $ getRdrName unitTyCon }
1807         | '(#' '#)'                     { LL $ getRdrName unboxedUnitTyCon }
1808
1809 ntgtycon :: { Located RdrName }  -- A "general" qualified tycon, excluding unit tuples
1810         : oqtycon                       { $1 }
1811         | '(' commas ')'                { LL $ getRdrName (tupleTyCon BoxedTuple ($2 + 1)) }
1812         | '(#' commas '#)'              { LL $ getRdrName (tupleTyCon UnboxedTuple ($2 + 1)) }
1813         | '(' '->' ')'                  { LL $ getRdrName funTyCon }
1814         | '[' ']'                       { LL $ listTyCon_RDR }
1815         | '[:' ':]'                     { LL $ parrTyCon_RDR }
1816         | '(' '~#' ')'                  { LL $ getRdrName eqPrimTyCon }
1817
1818 oqtycon :: { Located RdrName }  -- An "ordinary" qualified tycon;
1819                                 -- These can appear in export lists
1820         : qtycon                        { $1 }
1821         | '(' qtyconsym ')'             { LL (unLoc $2) }
1822         | '(' '~' ')'                   { LL $ eqTyCon_RDR }
1823
1824 qtyconop :: { Located RdrName } -- Qualified or unqualified
1825         : qtyconsym                     { $1 }
1826         | '`' qtycon '`'                { LL (unLoc $2) }
1827
1828 qtycon :: { Located RdrName }   -- Qualified or unqualified
1829         : QCONID                        { L1 $! mkQual tcClsName (getQCONID $1) }
1830         | PREFIXQCONSYM                 { L1 $! mkQual tcClsName (getPREFIXQCONSYM $1) }
1831         | tycon                         { $1 }
1832
1833 tycon   :: { Located RdrName }  -- Unqualified
1834         : CONID                         { L1 $! mkUnqual tcClsName (getCONID $1) }
1835
1836 qtyconsym :: { Located RdrName }
1837         : QCONSYM                       { L1 $! mkQual tcClsName (getQCONSYM $1) }
1838         | QVARSYM                       { L1 $! mkQual tcClsName (getQVARSYM $1) }
1839         | tyconsym                      { $1 }
1840
1841 -- Does not include "!", because that is used for strictness marks
1842 --               or ".", because that separates the quantified type vars from the rest
1843 tyconsym :: { Located RdrName }
1844         : CONSYM                        { L1 $! mkUnqual tcClsName (getCONSYM $1) }
1845         | VARSYM                        { L1 $! mkUnqual tcClsName (getVARSYM $1) }
1846         | '*'                           { L1 $! mkUnqual tcClsName (fsLit "*")    }
1847
1848
1849 -----------------------------------------------------------------------------
1850 -- Operators
1851
1852 op      :: { Located RdrName }   -- used in infix decls
1853         : varop                 { $1 }
1854         | conop                 { $1 }
1855
1856 varop   :: { Located RdrName }
1857         : varsym                { $1 }
1858         | '`' varid '`'         { LL (unLoc $2) }
1859
1860 qop     :: { LHsExpr RdrName }   -- used in sections
1861         : qvarop                { L1 $ HsVar (unLoc $1) }
1862         | qconop                { L1 $ HsVar (unLoc $1) }
1863
1864 qopm    :: { LHsExpr RdrName }   -- used in sections
1865         : qvaropm               { L1 $ HsVar (unLoc $1) }
1866         | qconop                { L1 $ HsVar (unLoc $1) }
1867
1868 qvarop :: { Located RdrName }
1869         : qvarsym               { $1 }
1870         | '`' qvarid '`'        { LL (unLoc $2) }
1871
1872 qvaropm :: { Located RdrName }
1873         : qvarsym_no_minus      { $1 }
1874         | '`' qvarid '`'        { LL (unLoc $2) }
1875
1876 -----------------------------------------------------------------------------
1877 -- Type variables
1878
1879 tyvar   :: { Located RdrName }
1880 tyvar   : tyvarid               { $1 }
1881
1882 tyvarop :: { Located RdrName }
1883 tyvarop : '`' tyvarid '`'       { LL (unLoc $2) }
1884         | '.'                   {% parseErrorSDoc (getLoc $1) 
1885                                       (vcat [ptext (sLit "Illegal symbol '.' in type"), 
1886                                              ptext (sLit "Perhaps you intended -XRankNTypes or similar flag"),
1887                                              ptext (sLit "to enable explicit-forall syntax: forall <tvs>. <type>")])
1888                                 }
1889
1890 tyvarid :: { Located RdrName }
1891         : VARID                 { L1 $! mkUnqual tvName (getVARID $1) }
1892         | special_id            { L1 $! mkUnqual tvName (unLoc $1) }
1893         | 'unsafe'              { L1 $! mkUnqual tvName (fsLit "unsafe") }
1894         | 'safe'                { L1 $! mkUnqual tvName (fsLit "safe") }
1895         | 'interruptible'       { L1 $! mkUnqual tvName (fsLit "interruptible") }
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 }