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