Fix API Annotations for unboxed sums
[ghc.git] / compiler / parser / Parser.y
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 -- | This module provides the generated Happy parser for Haskell. It exports
12 -- a number of parsers which may be used in any library that uses the GHC API.
13 -- A common usage pattern is to initialize the parser state with a given string
14 -- and then parse that string:
15 --
16 -- @
17 --     runParser :: DynFlags -> String -> P a -> ParseResult a
18 --     runParser flags str parser = unP parser parseState
19 --     where
20 --       filename = "\<interactive\>"
21 --       location = mkRealSrcLoc (mkFastString filename) 1 1
22 --       buffer = stringToStringBuffer str
23 --       parseState = mkPState flags buffer location
24 -- @
25 module Parser (parseModule, parseSignature, parseImport, parseStatement, parseBackpack,
26                parseDeclaration, parseExpression, parsePattern,
27                parseTypeSignature,
28                parseStmt, parseIdentifier,
29                parseType, parseHeader) where
30
31 -- base
32 import Control.Monad    ( unless, liftM )
33 import GHC.Exts
34 import Data.Char
35 import Control.Monad    ( mplus )
36 import Control.Applicative ((<$))
37
38 -- compiler/hsSyn
39 import HsSyn
40
41 -- compiler/main
42 import HscTypes         ( IsBootInterface, WarningTxt(..) )
43 import DynFlags
44 import BkpSyn
45 import PackageConfig
46
47 -- compiler/utils
48 import OrdList
49 import BooleanFormula   ( BooleanFormula(..), LBooleanFormula(..), mkTrue )
50 import FastString
51 import Maybes           ( orElse )
52 import Outputable
53
54 -- compiler/basicTypes
55 import RdrName
56 import OccName          ( varName, dataName, tcClsName, tvName, startsWithUnderscore )
57 import DataCon          ( DataCon, dataConName )
58 import SrcLoc
59 import Module
60 import BasicTypes
61
62 -- compiler/types
63 import Type             ( funTyCon )
64 import Kind             ( Kind )
65 import Class            ( FunDep )
66
67 -- compiler/parser
68 import RdrHsSyn
69 import Lexer
70 import HaddockUtils
71 import ApiAnnotation
72
73 -- compiler/typecheck
74 import TcEvidence       ( emptyTcEvBinds )
75
76 -- compiler/prelude
77 import ForeignCall
78 import TysPrim          ( eqPrimTyCon )
79 import PrelNames        ( eqTyCon_RDR )
80 import TysWiredIn       ( unitTyCon, unitDataCon, tupleTyCon, tupleDataCon, nilDataCon,
81                           unboxedUnitTyCon, unboxedUnitDataCon,
82                           listTyCon_RDR, parrTyCon_RDR, consDataCon_RDR )
83
84 -- compiler/utils
85 import Util             ( looksLikePackageName )
86 import Prelude
87
88 import qualified GHC.LanguageExtensions as LangExt
89 }
90
91 %expect 36 -- shift/reduce conflicts
92
93 {- Last updated: 3 Aug 2016
94
95 If you modify this parser and add a conflict, please update this comment.
96 You can learn more about the conflicts by passing 'happy' the -i flag:
97
98     happy -agc --strict compiler/parser/Parser.y -idetailed-info
99
100 How is this section formatted? Look up the state the conflict is
101 reported at, and copy the list of applicable rules (at the top, without the
102 rule numbers).  Mark *** for the rule that is the conflicting reduction (that
103 is, the interpretation which is NOT taken).  NB: Happy doesn't print a rule
104 in a state if it is empty, but you should include it in the list (you can
105 look these up in the Grammar section of the info file).
106
107 Obviously the state numbers are not stable across modifications to the parser,
108 the idea is to reproduce enough information on each conflict so you can figure
109 out what happened if the states were renumbered.  Try not to gratuitously move
110 productions around in this file.
111
112 -------------------------------------------------------------------------------
113
114 state 0 contains 1 shift/reduce conflicts.
115
116     Conflicts: DOCNEXT (empty missing_module_keyword reduces)
117
118 Ambiguity when the source file starts with "-- | doc". We need another
119 token of lookahead to determine if a top declaration or the 'module' keyword
120 follows. Shift parses as if the 'module' keyword follows.
121
122 -------------------------------------------------------------------------------
123
124 state 48 contains 2 shift/reduce conflicts.
125
126     *** strict_mark -> unpackedness .
127         strict_mark -> unpackedness . strictness
128
129     Conflicts: '~' '!'
130
131 -------------------------------------------------------------------------------
132
133 state 52 contains 1 shift/reduce conflict.
134
135         context -> btype .
136     *** type -> btype .
137         type -> btype . '->' ctype
138
139     Conflicts: '->'
140
141 -------------------------------------------------------------------------------
142
143 state 53 contains 9 shift/reduce conflicts.
144
145     *** btype -> tyapps .
146         tyapps -> tyapps . tyapp
147
148     Conflicts: ':' '-' '!' '.' '`' VARSYM CONSYM QVARSYM QCONSYM
149
150 -------------------------------------------------------------------------------
151
152 state 134 contains 14 shift/reduce conflicts.
153
154         exp -> infixexp . '::' sigtype
155         exp -> infixexp . '-<' exp
156         exp -> infixexp . '>-' exp
157         exp -> infixexp . '-<<' exp
158         exp -> infixexp . '>>-' exp
159     *** exp -> infixexp .
160         infixexp -> infixexp . qop exp10
161
162     Conflicts: ':' '::' '-' '!' '-<' '>-' '-<<' '>>-'
163                '.' '`' VARSYM CONSYM QVARSYM QCONSYM
164
165 Examples of ambiguity:
166     'if x then y else z -< e'
167     'if x then y else z :: T'
168     'if x then y else z + 1' (NB: '+' is in VARSYM)
169
170 Shift parses as (per longest-parse rule):
171     'if x then y else (z -< T)'
172     'if x then y else (z :: T)'
173     'if x then y else (z + 1)'
174
175 -------------------------------------------------------------------------------
176
177 state 299 contains 1 shift/reduce conflicts.
178
179         rule -> STRING . rule_activation rule_forall infixexp '=' exp
180
181     Conflict: '[' (empty rule_activation reduces)
182
183 We don't know whether the '[' starts the activation or not: it
184 might be the start of the declaration with the activation being
185 empty.  --SDM 1/4/2002
186
187 Example ambiguity:
188     '{-# RULE [0] f = ... #-}'
189
190 We parse this as having a [0] rule activation for rewriting 'f', rather
191 a rule instructing how to rewrite the expression '[0] f'.
192
193 -------------------------------------------------------------------------------
194
195 state 309 contains 1 shift/reduce conflict.
196
197     *** type -> btype .
198         type -> btype . '->' ctype
199
200     Conflict: '->'
201
202 Same as state 50 but without contexts.
203
204 -------------------------------------------------------------------------------
205
206 state 348 contains 1 shift/reduce conflicts.
207
208         tup_exprs -> commas . tup_tail
209         sysdcon_nolist -> '(' commas . ')'
210         commas -> commas . ','
211
212     Conflict: ')' (empty tup_tail reduces)
213
214 A tuple section with NO free variables '(,,)' is indistinguishable
215 from the Haskell98 data constructor for a tuple.  Shift resolves in
216 favor of sysdcon, which is good because a tuple section will get rejected
217 if -XTupleSections is not specified.
218
219 -------------------------------------------------------------------------------
220
221 state 402 contains 1 shift/reduce conflicts.
222
223         tup_exprs -> commas . tup_tail
224         sysdcon_nolist -> '(#' commas . '#)'
225         commas -> commas . ','
226
227     Conflict: '#)' (empty tup_tail reduces)
228
229 Same as State 324 for unboxed tuples.
230
231 -------------------------------------------------------------------------------
232
233 state 477 contains 1 shift/reduce conflict.
234
235         oqtycon -> '(' qtyconsym . ')'
236     *** qtyconop -> qtyconsym .
237
238     Conflict: ')'
239
240 TODO: Why?
241
242 -------------------------------------------------------------------------------
243
244 state 658 contains 1 shift/reduce conflicts.
245
246     *** aexp2 -> ipvar .
247         dbind -> ipvar . '=' exp
248
249     Conflict: '='
250
251 Example ambiguity: 'let ?x ...'
252
253 The parser can't tell whether the ?x is the lhs of a normal binding or
254 an implicit binding.  Fortunately, resolving as shift gives it the only
255 sensible meaning, namely the lhs of an implicit binding.
256
257 -------------------------------------------------------------------------------
258
259 state 731 contains 1 shift/reduce conflicts.
260
261         rule -> STRING rule_activation . rule_forall infixexp '=' exp
262
263     Conflict: 'forall' (empty rule_forall reduces)
264
265 Example ambiguity: '{-# RULES "name" forall = ... #-}'
266
267 'forall' is a valid variable name---we don't know whether
268 to treat a forall on the input as the beginning of a quantifier
269 or the beginning of the rule itself.  Resolving to shift means
270 it's always treated as a quantifier, hence the above is disallowed.
271 This saves explicitly defining a grammar for the rule lhs that
272 doesn't include 'forall'.
273
274 -------------------------------------------------------------------------------
275
276 state 963 contains 1 shift/reduce conflicts.
277
278         transformqual -> 'then' 'group' . 'using' exp
279         transformqual -> 'then' 'group' . 'by' exp 'using' exp
280     *** special_id -> 'group' .
281
282     Conflict: 'by'
283
284 -------------------------------------------------------------------------------
285
286 state 1303 contains 1 shift/reduce conflict.
287
288     *** atype -> tyvar .
289         tv_bndr -> '(' tyvar . '::' kind ')'
290
291     Conflict: '::'
292
293 TODO: Why?
294
295 -------------------------------------------------------------------------------
296 -- API Annotations
297 --
298
299 A lot of the productions are now cluttered with calls to
300 aa,am,ams,amms etc.
301
302 These are helper functions to make sure that the locations of the
303 various keywords such as do / let / in are captured for use by tools
304 that want to do source to source conversions, such as refactorers or
305 structured editors.
306
307 The helper functions are defined at the bottom of this file.
308
309 See
310   https://ghc.haskell.org/trac/ghc/wiki/ApiAnnotations and
311   https://ghc.haskell.org/trac/ghc/wiki/GhcAstAnnotations
312 for some background.
313
314 If you modify the parser and want to ensure that the API annotations are processed
315 correctly, see the README in (REPO)/utils/check-api-annotations for details on
316 how to set up a test using the check-api-annotations utility, and interpret the
317 output it generates.
318
319 Note [Parsing lists]
320 ---------------------
321 You might be wondering why we spend so much effort encoding our lists this
322 way:
323
324 importdecls
325         : importdecls ';' importdecl
326         | importdecls ';'
327         | importdecl
328         | {- empty -}
329
330 This might seem like an awfully roundabout way to declare a list; plus, to add
331 insult to injury you have to reverse the results at the end.  The answer is that
332 left recursion prevents us from running out of stack space when parsing long
333 sequences.  See: https://www.haskell.org/happy/doc/html/sec-sequences.html for
334 more guidance.
335
336 By adding/removing branches, you can affect what lists are accepted.  Here
337 are the most common patterns, rewritten as regular expressions for clarity:
338
339     -- Equivalent to: ';'* (x ';'+)* x?  (can be empty, permits leading/trailing semis)
340     xs : xs ';' x
341        | xs ';'
342        | x
343        | {- empty -}
344
345     -- Equivalent to x (';' x)* ';'*  (non-empty, permits trailing semis)
346     xs : xs ';' x
347        | xs ';'
348        | x
349
350     -- Equivalent to ';'* alts (';' alts)* ';'* (non-empty, permits leading/trailing semis)
351     alts : alts1
352          | ';' alts
353     alts1 : alts1 ';' alt
354           | alts1 ';'
355           | alt
356
357     -- Equivalent to x (',' x)+ (non-empty, no trailing semis)
358     xs : x
359        | x ',' xs
360
361 -- -----------------------------------------------------------------------------
362
363 -}
364
365 %token
366  '_'            { L _ ITunderscore }            -- Haskell keywords
367  'as'           { L _ ITas }
368  'case'         { L _ ITcase }
369  'class'        { L _ ITclass }
370  'data'         { L _ ITdata }
371  'default'      { L _ ITdefault }
372  'deriving'     { L _ ITderiving }
373  'do'           { L _ ITdo }
374  'else'         { L _ ITelse }
375  'hiding'       { L _ IThiding }
376  'if'           { L _ ITif }
377  'import'       { L _ ITimport }
378  'in'           { L _ ITin }
379  'infix'        { L _ ITinfix }
380  'infixl'       { L _ ITinfixl }
381  'infixr'       { L _ ITinfixr }
382  'instance'     { L _ ITinstance }
383  'let'          { L _ ITlet }
384  'module'       { L _ ITmodule }
385  'newtype'      { L _ ITnewtype }
386  'of'           { L _ ITof }
387  'qualified'    { L _ ITqualified }
388  'then'         { L _ ITthen }
389  'type'         { L _ ITtype }
390  'where'        { L _ ITwhere }
391
392  'forall'       { L _ (ITforall _) }                -- GHC extension keywords
393  'foreign'      { L _ ITforeign }
394  'export'       { L _ ITexport }
395  'label'        { L _ ITlabel }
396  'dynamic'      { L _ ITdynamic }
397  'safe'         { L _ ITsafe }
398  'interruptible' { L _ ITinterruptible }
399  'unsafe'       { L _ ITunsafe }
400  'mdo'          { L _ ITmdo }
401  'family'       { L _ ITfamily }
402  'role'         { L _ ITrole }
403  'stdcall'      { L _ ITstdcallconv }
404  'ccall'        { L _ ITccallconv }
405  'capi'         { L _ ITcapiconv }
406  'prim'         { L _ ITprimcallconv }
407  'javascript'   { L _ ITjavascriptcallconv }
408  'proc'         { L _ ITproc }          -- for arrow notation extension
409  'rec'          { L _ ITrec }           -- for arrow notation extension
410  'group'    { L _ ITgroup }     -- for list transform extension
411  'by'       { L _ ITby }        -- for list transform extension
412  'using'    { L _ ITusing }     -- for list transform extension
413  'pattern'      { L _ ITpattern } -- for pattern synonyms
414  'static'       { L _ ITstatic }  -- for static pointers extension
415  'stock'        { L _ ITstock }    -- for DerivingStrategies extension
416  'anyclass'     { L _ ITanyclass } -- for DerivingStrategies extension
417
418  'unit'         { L _ ITunit }
419  'signature'    { L _ ITsignature }
420  'dependency'   { L _ ITdependency }
421
422  '{-# INLINE'             { L _ (ITinline_prag _ _ _) } -- INLINE or INLINABLE
423  '{-# SPECIALISE'         { L _ (ITspec_prag _) }
424  '{-# SPECIALISE_INLINE'  { L _ (ITspec_inline_prag _ _) }
425  '{-# SOURCE'             { L _ (ITsource_prag _) }
426  '{-# RULES'              { L _ (ITrules_prag _) }
427  '{-# CORE'               { L _ (ITcore_prag _) }      -- hdaume: annotated core
428  '{-# SCC'                { L _ (ITscc_prag _)}
429  '{-# GENERATED'          { L _ (ITgenerated_prag _) }
430  '{-# DEPRECATED'         { L _ (ITdeprecated_prag _) }
431  '{-# WARNING'            { L _ (ITwarning_prag _) }
432  '{-# UNPACK'             { L _ (ITunpack_prag _) }
433  '{-# NOUNPACK'           { L _ (ITnounpack_prag _) }
434  '{-# ANN'                { L _ (ITann_prag _) }
435  '{-# VECTORISE'          { L _ (ITvect_prag _) }
436  '{-# VECTORISE_SCALAR'   { L _ (ITvect_scalar_prag _) }
437  '{-# NOVECTORISE'        { L _ (ITnovect_prag _) }
438  '{-# MINIMAL'            { L _ (ITminimal_prag _) }
439  '{-# CTYPE'              { L _ (ITctype _) }
440  '{-# OVERLAPPING'        { L _ (IToverlapping_prag _) }
441  '{-# OVERLAPPABLE'       { L _ (IToverlappable_prag _) }
442  '{-# OVERLAPS'           { L _ (IToverlaps_prag _) }
443  '{-# INCOHERENT'         { L _ (ITincoherent_prag _) }
444  '#-}'                    { L _ ITclose_prag }
445
446  '..'           { L _ ITdotdot }                        -- reserved symbols
447  ':'            { L _ ITcolon }
448  '::'           { L _ (ITdcolon _) }
449  '='            { L _ ITequal }
450  '\\'           { L _ ITlam }
451  'lcase'        { L _ ITlcase }
452  '|'            { L _ ITvbar }
453  '<-'           { L _ (ITlarrow _) }
454  '->'           { L _ (ITrarrow _) }
455  '@'            { L _ ITat }
456  '~'            { L _ ITtilde }
457  '~#'           { L _ ITtildehsh }
458  '=>'           { L _ (ITdarrow _) }
459  '-'            { L _ ITminus }
460  '!'            { L _ ITbang }
461  '-<'           { L _ (ITlarrowtail _) }            -- for arrow notation
462  '>-'           { L _ (ITrarrowtail _) }            -- for arrow notation
463  '-<<'          { L _ (ITLarrowtail _) }            -- for arrow notation
464  '>>-'          { L _ (ITRarrowtail _) }            -- for arrow notation
465  '.'            { L _ ITdot }
466  TYPEAPP        { L _ ITtypeApp }
467
468  '{'            { L _ ITocurly }                        -- special symbols
469  '}'            { L _ ITccurly }
470  vocurly        { L _ ITvocurly } -- virtual open curly (from layout)
471  vccurly        { L _ ITvccurly } -- virtual close curly (from layout)
472  '['            { L _ ITobrack }
473  ']'            { L _ ITcbrack }
474  '[:'           { L _ ITopabrack }
475  ':]'           { L _ ITcpabrack }
476  '('            { L _ IToparen }
477  ')'            { L _ ITcparen }
478  '(#'           { L _ IToubxparen }
479  '#)'           { L _ ITcubxparen }
480  '(|'           { L _ (IToparenbar _) }
481  '|)'           { L _ (ITcparenbar _) }
482  ';'            { L _ ITsemi }
483  ','            { L _ ITcomma }
484  '`'            { L _ ITbackquote }
485  SIMPLEQUOTE    { L _ ITsimpleQuote      }     -- 'x
486
487  VARID          { L _ (ITvarid    _) }          -- identifiers
488  CONID          { L _ (ITconid    _) }
489  VARSYM         { L _ (ITvarsym   _) }
490  CONSYM         { L _ (ITconsym   _) }
491  QVARID         { L _ (ITqvarid   _) }
492  QCONID         { L _ (ITqconid   _) }
493  QVARSYM        { L _ (ITqvarsym  _) }
494  QCONSYM        { L _ (ITqconsym  _) }
495
496  IPDUPVARID     { L _ (ITdupipvarid   _) }              -- GHC extension
497  LABELVARID     { L _ (ITlabelvarid   _) }
498
499  CHAR           { L _ (ITchar   _ _) }
500  STRING         { L _ (ITstring _ _) }
501  INTEGER        { L _ (ITinteger _ _) }
502  RATIONAL       { L _ (ITrational _) }
503
504  PRIMCHAR       { L _ (ITprimchar   _ _) }
505  PRIMSTRING     { L _ (ITprimstring _ _) }
506  PRIMINTEGER    { L _ (ITprimint    _ _) }
507  PRIMWORD       { L _ (ITprimword   _ _) }
508  PRIMFLOAT      { L _ (ITprimfloat  _) }
509  PRIMDOUBLE     { L _ (ITprimdouble _) }
510
511  DOCNEXT        { L _ (ITdocCommentNext _) }
512  DOCPREV        { L _ (ITdocCommentPrev _) }
513  DOCNAMED       { L _ (ITdocCommentNamed _) }
514  DOCSECTION     { L _ (ITdocSection _ _) }
515
516 -- Template Haskell
517 '[|'            { L _ (ITopenExpQuote _ _) }
518 '[p|'           { L _ ITopenPatQuote  }
519 '[t|'           { L _ ITopenTypQuote  }
520 '[d|'           { L _ ITopenDecQuote  }
521 '|]'            { L _ (ITcloseQuote _) }
522 '[||'           { L _ (ITopenTExpQuote _) }
523 '||]'           { L _ ITcloseTExpQuote  }
524 TH_ID_SPLICE    { L _ (ITidEscape _)  }     -- $x
525 '$('            { L _ ITparenEscape   }     -- $( exp )
526 TH_ID_TY_SPLICE { L _ (ITidTyEscape _)  }   -- $$x
527 '$$('           { L _ ITparenTyEscape   }   -- $$( exp )
528 TH_TY_QUOTE     { L _ ITtyQuote       }      -- ''T
529 TH_QUASIQUOTE   { L _ (ITquasiQuote _) }
530 TH_QQUASIQUOTE  { L _ (ITqQuasiQuote _) }
531
532 %monad { P } { >>= } { return }
533 %lexer { (lexer True) } { L _ ITeof }
534 %tokentype { (Located Token) }
535
536 -- Exported parsers
537 %name parseModule module
538 %name parseSignature signature
539 %name parseImport importdecl
540 %name parseStatement stmt
541 %name parseDeclaration topdecl
542 %name parseExpression exp
543 %name parsePattern pat
544 %name parseTypeSignature sigdecl
545 %name parseStmt   maybe_stmt
546 %name parseIdentifier  identifier
547 %name parseType ctype
548 %name parseBackpack backpack
549 %partial parseHeader header
550 %%
551
552 -----------------------------------------------------------------------------
553 -- Identifiers; one of the entry points
554 identifier :: { Located RdrName }
555         : qvar                          { $1 }
556         | qcon                          { $1 }
557         | qvarop                        { $1 }
558         | qconop                        { $1 }
559     | '(' '->' ')'      {% ams (sLL $1 $> $ getRdrName funTyCon)
560                                [mj AnnOpenP $1,mu AnnRarrow $2,mj AnnCloseP $3] }
561
562 -----------------------------------------------------------------------------
563 -- Backpack stuff
564
565 backpack :: { [LHsUnit PackageName] }
566          : implicit_top units close { fromOL $2 }
567          | '{' units '}'            { fromOL $2 }
568
569 units :: { OrdList (LHsUnit PackageName) }
570          : units ';' unit { $1 `appOL` unitOL $3 }
571          | units ';'      { $1 }
572          | unit           { unitOL $1 }
573
574 unit :: { LHsUnit PackageName }
575         : 'unit' pkgname 'where' unitbody
576             { sL1 $1 $ HsUnit { hsunitName = $2
577                               , hsunitBody = fromOL $4 } }
578
579 unitid :: { LHsUnitId PackageName }
580         : pkgname                  { sL1 $1 $ HsUnitId $1 [] }
581         | pkgname '[' msubsts ']'  { sLL $1 $> $ HsUnitId $1 (fromOL $3) }
582
583 msubsts :: { OrdList (LHsModuleSubst PackageName) }
584         : msubsts ',' msubst { $1 `appOL` unitOL $3 }
585         | msubsts ','        { $1 }
586         | msubst             { unitOL $1 }
587
588 msubst :: { LHsModuleSubst PackageName }
589         : modid '=' moduleid { sLL $1 $> $ ($1, $3) }
590         | modid VARSYM modid VARSYM { sLL $1 $> $ ($1, sLL $2 $> $ HsModuleVar $3) }
591
592 moduleid :: { LHsModuleId PackageName }
593           : VARSYM modid VARSYM { sLL $1 $> $ HsModuleVar $2 }
594           | unitid ':' modid    { sLL $1 $> $ HsModuleId $1 $3 }
595
596 pkgname :: { Located PackageName }
597         : STRING     { sL1 $1 $ PackageName (getSTRING $1) }
598         | litpkgname { sL1 $1 $ PackageName (unLoc $1) }
599
600 litpkgname_segment :: { Located FastString }
601         : VARID  { sL1 $1 $ getVARID $1 }
602         | CONID  { sL1 $1 $ getCONID $1 }
603         | special_id { $1 }
604
605 litpkgname :: { Located FastString }
606         : litpkgname_segment { $1 }
607         -- a bit of a hack, means p - b is parsed same as p-b, enough for now.
608         | litpkgname_segment '-' litpkgname  { sLL $1 $> $ appendFS (unLoc $1) (consFS '-' (unLoc $3)) }
609
610 mayberns :: { Maybe [LRenaming] }
611         : {- empty -} { Nothing }
612         | '(' rns ')' { Just (fromOL $2) }
613
614 rns :: { OrdList LRenaming }
615         : rns ',' rn { $1 `appOL` unitOL $3 }
616         | rns ','    { $1 }
617         | rn         { unitOL $1 }
618
619 rn :: { LRenaming }
620         : modid 'as' modid { sLL $1 $> $ Renaming $1 (Just $3) }
621         | modid            { sL1 $1    $ Renaming $1 Nothing }
622
623 unitbody :: { OrdList (LHsUnitDecl PackageName) }
624         : '{'     unitdecls '}'   { $2 }
625         | vocurly unitdecls close { $2 }
626
627 unitdecls :: { OrdList (LHsUnitDecl PackageName) }
628         : unitdecls ';' unitdecl { $1 `appOL` unitOL $3 }
629         | unitdecls ';'         { $1 }
630         | unitdecl              { unitOL $1 }
631
632 unitdecl :: { LHsUnitDecl PackageName }
633         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' body
634              -- XXX not accurate
635              { sL1 $2 $ DeclD ModuleD $3 (Just (sL1 $2 (HsModule (Just $3) $5 (fst $ snd $7) (snd $ snd $7) $4 $1))) }
636         | maybedocheader 'signature' modid maybemodwarning maybeexports 'where' body
637              { sL1 $2 $ DeclD SignatureD $3 (Just (sL1 $2 (HsModule (Just $3) $5 (fst $ snd $7) (snd $ snd $7) $4 $1))) }
638         -- NB: MUST have maybedocheader here, otherwise shift-reduce conflict
639         -- will prevent us from parsing both forms.
640         | maybedocheader 'module' modid
641              { sL1 $2 $ DeclD ModuleD $3 Nothing }
642         | maybedocheader 'signature' modid
643              { sL1 $2 $ DeclD SignatureD $3 Nothing }
644         | 'dependency' unitid mayberns
645              { sL1 $1 $ IncludeD (IncludeDecl { idUnitId = $2
646                                               , idModRenaming = $3
647                                               , idSignatureInclude = False }) }
648         | 'dependency' 'signature' unitid
649              { sL1 $1 $ IncludeD (IncludeDecl { idUnitId = $3
650                                               , idModRenaming = Nothing
651                                               , idSignatureInclude = True }) }
652
653 -----------------------------------------------------------------------------
654 -- Module Header
655
656 -- The place for module deprecation is really too restrictive, but if it
657 -- was allowed at its natural place just before 'module', we get an ugly
658 -- s/r conflict with the second alternative. Another solution would be the
659 -- introduction of a new pragma DEPRECATED_MODULE, but this is not very nice,
660 -- either, and DEPRECATED is only expected to be used by people who really
661 -- know what they are doing. :-)
662
663 signature :: { Located (HsModule RdrName) }
664        : maybedocheader 'signature' modid maybemodwarning maybeexports 'where' body
665              {% fileSrcSpan >>= \ loc ->
666                 ams (L loc (HsModule (Just $3) $5 (fst $ snd $7)
667                               (snd $ snd $7) $4 $1)
668                     )
669                     ([mj AnnModule $2, mj AnnWhere $6] ++ fst $7) }
670
671 module :: { Located (HsModule RdrName) }
672        : maybedocheader 'module' modid maybemodwarning maybeexports 'where' body
673              {% fileSrcSpan >>= \ loc ->
674                 ams (L loc (HsModule (Just $3) $5 (fst $ snd $7)
675                               (snd $ snd $7) $4 $1)
676                     )
677                     ([mj AnnModule $2, mj AnnWhere $6] ++ fst $7) }
678         | body2
679                 {% fileSrcSpan >>= \ loc ->
680                    ams (L loc (HsModule Nothing Nothing
681                                (fst $ snd $1) (snd $ snd $1) Nothing Nothing))
682                        (fst $1) }
683
684 maybedocheader :: { Maybe LHsDocString }
685         : moduleheader            { $1 }
686         | {- empty -}             { Nothing }
687
688 missing_module_keyword :: { () }
689         : {- empty -}                           {% pushModuleContext }
690
691 implicit_top :: { () }
692         : {- empty -}                           {% pushModuleContext }
693
694 maybemodwarning :: { Maybe (Located WarningTxt) }
695     : '{-# DEPRECATED' strings '#-}'
696                       {% ajs (Just (sLL $1 $> $ DeprecatedTxt (sL1 $1 (getDEPRECATED_PRAGs $1)) (snd $ unLoc $2)))
697                              (mo $1:mc $3: (fst $ unLoc $2)) }
698     | '{-# WARNING' strings '#-}'
699                          {% ajs (Just (sLL $1 $> $ WarningTxt (sL1 $1 (getWARNING_PRAGs $1)) (snd $ unLoc $2)))
700                                 (mo $1:mc $3 : (fst $ unLoc $2)) }
701     |  {- empty -}                  { Nothing }
702
703 body    :: { ([AddAnn]
704              ,([LImportDecl RdrName], [LHsDecl RdrName])) }
705         :  '{'            top '}'      { (moc $1:mcc $3:(fst $2)
706                                          , snd $2) }
707         |      vocurly    top close    { (fst $2, snd $2) }
708
709 body2   :: { ([AddAnn]
710              ,([LImportDecl RdrName], [LHsDecl RdrName])) }
711         :  '{' top '}'                          { (moc $1:mcc $3
712                                                    :(fst $2), snd $2) }
713         |  missing_module_keyword top close     { ([],snd $2) }
714
715
716 top     :: { ([AddAnn]
717              ,([LImportDecl RdrName], [LHsDecl RdrName])) }
718         : semis top1                            { ($1, $2) }
719
720 top1    :: { ([LImportDecl RdrName], [LHsDecl RdrName]) }
721         : importdecls_semi topdecls_semi        { (reverse $1, cvTopDecls $2) }
722         | importdecls_semi topdecls             { (reverse $1, cvTopDecls $2) }
723         | importdecls                           { (reverse $1, []) }
724
725 -----------------------------------------------------------------------------
726 -- Module declaration & imports only
727
728 header  :: { Located (HsModule RdrName) }
729         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' header_body
730                 {% fileSrcSpan >>= \ loc ->
731                    ams (L loc (HsModule (Just $3) $5 $7 [] $4 $1
732                           )) [mj AnnModule $2,mj AnnWhere $6] }
733         | maybedocheader 'signature' modid maybemodwarning maybeexports 'where' header_body
734                 {% fileSrcSpan >>= \ loc ->
735                    ams (L loc (HsModule (Just $3) $5 $7 [] $4 $1
736                           )) [mj AnnModule $2,mj AnnWhere $6] }
737         | header_body2
738                 {% fileSrcSpan >>= \ loc ->
739                    return (L loc (HsModule Nothing Nothing $1 [] Nothing
740                           Nothing)) }
741
742 header_body :: { [LImportDecl RdrName] }
743         :  '{'            header_top            { $2 }
744         |      vocurly    header_top            { $2 }
745
746 header_body2 :: { [LImportDecl RdrName] }
747         :  '{' header_top                       { $2 }
748         |  missing_module_keyword header_top    { $2 }
749
750 header_top :: { [LImportDecl RdrName] }
751         :  semis header_top_importdecls         { $2 }
752
753 header_top_importdecls :: { [LImportDecl RdrName] }
754         :  importdecls_semi                     { $1 }
755         |  importdecls                          { $1 }
756
757 -----------------------------------------------------------------------------
758 -- The Export List
759
760 maybeexports :: { (Maybe (Located [LIE RdrName])) }
761         :  '(' exportlist ')'       {% ams (sLL $1 $> ()) [mop $1,mcp $3] >>
762                                        return (Just (sLL $1 $> (fromOL $2))) }
763         |  {- empty -}              { Nothing }
764
765 exportlist :: { OrdList (LIE RdrName) }
766         : expdoclist ',' expdoclist   {% addAnnotation (oll $1) AnnComma (gl $2)
767                                          >> return ($1 `appOL` $3) }
768         | exportlist1                 { $1 }
769
770 exportlist1 :: { OrdList (LIE RdrName) }
771         : expdoclist export expdoclist ',' exportlist1
772                           {% (addAnnotation (oll ($1 `appOL` $2 `appOL` $3))
773                                             AnnComma (gl $4) ) >>
774                               return ($1 `appOL` $2 `appOL` $3 `appOL` $5) }
775         | expdoclist export expdoclist             { $1 `appOL` $2 `appOL` $3 }
776         | expdoclist                               { $1 }
777
778 expdoclist :: { OrdList (LIE RdrName) }
779         : exp_doc expdoclist                           { $1 `appOL` $2 }
780         | {- empty -}                                  { nilOL }
781
782 exp_doc :: { OrdList (LIE RdrName) }
783         : docsection    { unitOL (sL1 $1 (case (unLoc $1) of (n, doc) -> IEGroup n doc)) }
784         | docnamed      { unitOL (sL1 $1 (IEDocNamed ((fst . unLoc) $1))) }
785         | docnext       { unitOL (sL1 $1 (IEDoc (unLoc $1))) }
786
787
788    -- No longer allow things like [] and (,,,) to be exported
789    -- They are built in syntax, always available
790 export  :: { OrdList (LIE RdrName) }
791         : qcname_ext export_subspec  {% mkModuleImpExp $1 (snd $ unLoc $2)
792                                           >>= \ie -> amsu (sLL $1 $> ie) (fst $ unLoc $2) }
793         |  'module' modid            {% amsu (sLL $1 $> (IEModuleContents $2))
794                                              [mj AnnModule $1] }
795         |  'pattern' qcon            {% amsu (sLL $1 $> (IEVar $2))
796                                              [mj AnnPattern $1] }
797
798 export_subspec :: { Located ([AddAnn],ImpExpSubSpec) }
799         : {- empty -}             { sL0 ([],ImpExpAbs) }
800         | '(' qcnames ')'         {% mkImpExpSubSpec (reverse (snd $2))
801                                       >>= \(as,ie) -> return $ sLL $1 $>
802                                             (as ++ [mop $1,mcp $3] ++ fst $2, ie) }
803
804
805 qcnames :: { ([AddAnn], [Located (Maybe RdrName)]) }
806   : {- empty -}                   { ([],[]) }
807   | qcnames1                      { $1 }
808
809 qcnames1 :: { ([AddAnn], [Located (Maybe RdrName)]) }     -- A reversed list
810         :  qcnames1 ',' qcname_ext_w_wildcard  {% case (head (snd $1)) of
811                                                     l@(L _ Nothing) ->
812                                                        return ([mj AnnComma $2, mj AnnDotdot l]
813                                                                ,(snd (unLoc $3)  : snd $1))
814                                                     l -> (ams (head (snd $1)) [mj AnnComma $2] >>
815                                                           return (fst $1 ++ fst (unLoc $3),
816                                                                   snd (unLoc $3) : snd $1)) }
817
818
819         -- Annotations re-added in mkImpExpSubSpec
820         |  qcname_ext_w_wildcard                   { (fst (unLoc $1),[snd (unLoc $1)]) }
821
822 -- Variable, data constructor or wildcard
823 -- or tagged type constructor
824 qcname_ext_w_wildcard :: { Located ([AddAnn],Located (Maybe RdrName)) }
825         :  qcname_ext               { sL1 $1 ([],Just `fmap` $1) }
826         |  '..'                     { sL1 $1 ([mj AnnDotdot $1], sL1 $1 Nothing) }
827
828 qcname_ext :: { Located RdrName }
829         :  qcname                   { $1 }
830         |  'type' oqtycon           {% amms (mkTypeImpExp (sLL $1 $> (unLoc $2)))
831                                             [mj AnnType $1,mj AnnVal $2] }
832
833 qcname  :: { Located RdrName }  -- Variable or type constructor
834         :  qvar                 { $1 } -- Things which look like functions
835                                        -- Note: This includes record selectors but
836                                        -- also (-.->), see #11432
837         |  oqtycon_no_varcon    { $1 } -- see Note [Type constructors in export list]
838
839 -----------------------------------------------------------------------------
840 -- Import Declarations
841
842 -- importdecls and topdecls must contain at least one declaration;
843 -- top handles the fact that these may be optional.
844
845 -- One or more semicolons
846 semis1  :: { [AddAnn] }
847 semis1  : semis1 ';'  { mj AnnSemi $2 : $1 }
848         | ';'         { [mj AnnSemi $1] }
849
850 -- Zero or more semicolons
851 semis   :: { [AddAnn] }
852 semis   : semis ';'   { mj AnnSemi $2 : $1 }
853         | {- empty -} { [] }
854
855 -- No trailing semicolons, non-empty
856 importdecls :: { [LImportDecl RdrName] }
857 importdecls
858         : importdecls_semi importdecl
859                                 { $2 : $1 }
860
861 -- May have trailing semicolons, can be empty
862 importdecls_semi :: { [LImportDecl RdrName] }
863 importdecls_semi
864         : importdecls_semi importdecl semis1
865                                 {% ams $2 $3 >> return ($2 : $1) }
866         | {- empty -}           { [] }
867
868 importdecl :: { LImportDecl RdrName }
869         : 'import' maybe_src maybe_safe optqualified maybe_pkg modid maybeas maybeimpspec
870                 {% ams (L (comb4 $1 $6 (snd $7) $8) $
871                   ImportDecl { ideclSourceSrc = snd $ fst $2
872                              , ideclName = $6, ideclPkgQual = snd $5
873                              , ideclSource = snd $2, ideclSafe = snd $3
874                              , ideclQualified = snd $4, ideclImplicit = False
875                              , ideclAs = unLoc (snd $7)
876                              , ideclHiding = unLoc $8 })
877                    ((mj AnnImport $1 : (fst $ fst $2) ++ fst $3 ++ fst $4
878                                     ++ fst $5 ++ fst $7)) }
879
880 maybe_src :: { (([AddAnn],SourceText),IsBootInterface) }
881         : '{-# SOURCE' '#-}'        { (([mo $1,mc $2],getSOURCE_PRAGs $1)
882                                       ,True) }
883         | {- empty -}               { (([],NoSourceText),False) }
884
885 maybe_safe :: { ([AddAnn],Bool) }
886         : 'safe'                                { ([mj AnnSafe $1],True) }
887         | {- empty -}                           { ([],False) }
888
889 maybe_pkg :: { ([AddAnn],Maybe StringLiteral) }
890         : STRING  {% let pkgFS = getSTRING $1 in
891                      if looksLikePackageName (unpackFS pkgFS)
892                         then return ([mj AnnPackageName $1], Just (StringLiteral (getSTRINGs $1) pkgFS))
893                         else parseErrorSDoc (getLoc $1) $ vcat [
894                              text "parse error" <> colon <+> quotes (ppr pkgFS),
895                              text "Version number or non-alphanumeric" <+>
896                              text "character in package name"] }
897         | {- empty -}                           { ([],Nothing) }
898
899 optqualified :: { ([AddAnn],Bool) }
900         : 'qualified'                           { ([mj AnnQualified $1],True)  }
901         | {- empty -}                           { ([],False) }
902
903 maybeas :: { ([AddAnn],Located (Maybe (Located ModuleName))) }
904         : 'as' modid                           { ([mj AnnAs $1]
905                                                  ,sLL $1 $> (Just $2)) }
906         | {- empty -}                          { ([],noLoc Nothing) }
907
908 maybeimpspec :: { Located (Maybe (Bool, Located [LIE RdrName])) }
909         : impspec                  {% let (b, ie) = unLoc $1 in
910                                        checkImportSpec ie
911                                         >>= \checkedIe ->
912                                           return (L (gl $1) (Just (b, checkedIe)))  }
913         | {- empty -}              { noLoc Nothing }
914
915 impspec :: { Located (Bool, Located [LIE RdrName]) }
916         :  '(' exportlist ')'               {% ams (sLL $1 $> (False,
917                                                       sLL $1 $> $ fromOL $2))
918                                                    [mop $1,mcp $3] }
919         |  'hiding' '(' exportlist ')'      {% ams (sLL $1 $> (True,
920                                                       sLL $1 $> $ fromOL $3))
921                                                [mj AnnHiding $1,mop $2,mcp $4] }
922
923 -----------------------------------------------------------------------------
924 -- Fixity Declarations
925
926 prec    :: { Located (SourceText,Int) }
927         : {- empty -}           { noLoc (NoSourceText,9) }
928         | INTEGER
929                  {% checkPrecP (sL1 $1 (getINTEGERs $1,fromInteger (getINTEGER $1))) }
930
931 infix   :: { Located FixityDirection }
932         : 'infix'                               { sL1 $1 InfixN  }
933         | 'infixl'                              { sL1 $1 InfixL  }
934         | 'infixr'                              { sL1 $1 InfixR }
935
936 ops     :: { Located (OrdList (Located RdrName)) }
937         : ops ',' op       {% addAnnotation (oll $ unLoc $1) AnnComma (gl $2) >>
938                               return (sLL $1 $> ((unLoc $1) `appOL` unitOL $3))}
939         | op               { sL1 $1 (unitOL $1) }
940
941 -----------------------------------------------------------------------------
942 -- Top-Level Declarations
943
944 -- No trailing semicolons, non-empty
945 topdecls :: { OrdList (LHsDecl RdrName) }
946         : topdecls_semi topdecl        { $1 `snocOL` $2 }
947
948 -- May have trailing semicolons, can be empty
949 topdecls_semi :: { OrdList (LHsDecl RdrName) }
950         : topdecls_semi topdecl semis1 {% ams $2 $3 >> return ($1 `snocOL` $2) }
951         | {- empty -}                  { nilOL }
952
953 topdecl :: { LHsDecl RdrName }
954         : cl_decl                               { sL1 $1 (TyClD (unLoc $1)) }
955         | ty_decl                               { sL1 $1 (TyClD (unLoc $1)) }
956         | inst_decl                             { sL1 $1 (InstD (unLoc $1)) }
957         | stand_alone_deriving                  { sLL $1 $> (DerivD (unLoc $1)) }
958         | role_annot                            { sL1 $1 (RoleAnnotD (unLoc $1)) }
959         | 'default' '(' comma_types0 ')'    {% ams (sLL $1 $> (DefD (DefaultDecl $3)))
960                                                          [mj AnnDefault $1
961                                                          ,mop $2,mcp $4] }
962         | 'foreign' fdecl          {% ams (sLL $1 $> (snd $ unLoc $2))
963                                            (mj AnnForeign $1:(fst $ unLoc $2)) }
964         | '{-# DEPRECATED' deprecations '#-}'   {% ams (sLL $1 $> $ WarningD (Warnings (getDEPRECATED_PRAGs $1) (fromOL $2)))
965                                                        [mo $1,mc $3] }
966         | '{-# WARNING' warnings '#-}'          {% ams (sLL $1 $> $ WarningD (Warnings (getWARNING_PRAGs $1) (fromOL $2)))
967                                                        [mo $1,mc $3] }
968         | '{-# RULES' rules '#-}'               {% ams (sLL $1 $> $ RuleD (HsRules (getRULES_PRAGs $1) (fromOL $2)))
969                                                        [mo $1,mc $3] }
970         | '{-# VECTORISE' qvar '=' exp '#-}' {% ams (sLL $1 $> $ VectD (HsVect (getVECT_PRAGs $1) $2 $4))
971                                                     [mo $1,mj AnnEqual $3
972                                                     ,mc $5] }
973         | '{-# NOVECTORISE' qvar '#-}'       {% ams (sLL $1 $> $ VectD (HsNoVect (getNOVECT_PRAGs $1) $2))
974                                                      [mo $1,mc $3] }
975         | '{-# VECTORISE' 'type' gtycon '#-}'
976                                 {% ams (sLL $1 $> $
977                                     VectD (HsVectTypeIn (getVECT_PRAGs $1) False $3 Nothing))
978                                     [mo $1,mj AnnType $2,mc $4] }
979
980         | '{-# VECTORISE_SCALAR' 'type' gtycon '#-}'
981                                 {% ams (sLL $1 $> $
982                                     VectD (HsVectTypeIn (getVECT_SCALAR_PRAGs $1) True $3 Nothing))
983                                     [mo $1,mj AnnType $2,mc $4] }
984
985         | '{-# VECTORISE' 'type' gtycon '=' gtycon '#-}'
986                                 {% ams (sLL $1 $> $
987                                     VectD (HsVectTypeIn (getVECT_PRAGs $1) False $3 (Just $5)))
988                                     [mo $1,mj AnnType $2,mj AnnEqual $4,mc $6] }
989         | '{-# VECTORISE_SCALAR' 'type' gtycon '=' gtycon '#-}'
990                                 {% ams (sLL $1 $> $
991                                     VectD (HsVectTypeIn (getVECT_SCALAR_PRAGs $1) True $3 (Just $5)))
992                                     [mo $1,mj AnnType $2,mj AnnEqual $4,mc $6] }
993
994         | '{-# VECTORISE' 'class' gtycon '#-}'
995                                          {% ams (sLL $1 $>  $ VectD (HsVectClassIn (getVECT_PRAGs $1) $3))
996                                                  [mo $1,mj AnnClass $2,mc $4] }
997         | annotation { $1 }
998         | decl_no_th                            { $1 }
999
1000         -- Template Haskell Extension
1001         -- The $(..) form is one possible form of infixexp
1002         -- but we treat an arbitrary expression just as if
1003         -- it had a $(..) wrapped around it
1004         | infixexp_top                          { sLL $1 $> $ mkSpliceDecl $1 }
1005
1006 -- Type classes
1007 --
1008 cl_decl :: { LTyClDecl RdrName }
1009         : 'class' tycl_hdr fds where_cls
1010                 {% amms (mkClassDecl (comb4 $1 $2 $3 $4) $2 $3 (snd $ unLoc $4))
1011                         (mj AnnClass $1:(fst $ unLoc $3)++(fst $ unLoc $4)) }
1012
1013 -- Type declarations (toplevel)
1014 --
1015 ty_decl :: { LTyClDecl RdrName }
1016            -- ordinary type synonyms
1017         : 'type' type '=' ctypedoc
1018                 -- Note ctype, not sigtype, on the right of '='
1019                 -- We allow an explicit for-all but we don't insert one
1020                 -- in   type Foo a = (b,b)
1021                 -- Instead we just say b is out of scope
1022                 --
1023                 -- Note the use of type for the head; this allows
1024                 -- infix type constructors to be declared
1025                 {% amms (mkTySynonym (comb2 $1 $4) $2 $4)
1026                         [mj AnnType $1,mj AnnEqual $3] }
1027
1028            -- type family declarations
1029         | 'type' 'family' type opt_tyfam_kind_sig opt_injective_info
1030                           where_type_family
1031                 -- Note the use of type for the head; this allows
1032                 -- infix type constructors to be declared
1033                 {% amms (mkFamDecl (comb4 $1 $3 $4 $5) (snd $ unLoc $6) $3
1034                                    (snd $ unLoc $4) (snd $ unLoc $5))
1035                         (mj AnnType $1:mj AnnFamily $2:(fst $ unLoc $4)
1036                            ++ (fst $ unLoc $5) ++ (fst $ unLoc $6)) }
1037
1038           -- ordinary data type or newtype declaration
1039         | data_or_newtype capi_ctype tycl_hdr constrs maybe_derivings
1040                 {% amms (mkTyData (comb4 $1 $3 $4 $5) (snd $ unLoc $1) $2 $3
1041                            Nothing (reverse (snd $ unLoc $4))
1042                                    (fmap reverse $5))
1043                                    -- We need the location on tycl_hdr in case
1044                                    -- constrs and deriving are both empty
1045                         ((fst $ unLoc $1):(fst $ unLoc $4)) }
1046
1047           -- ordinary GADT declaration
1048         | data_or_newtype capi_ctype tycl_hdr opt_kind_sig
1049                  gadt_constrlist
1050                  maybe_derivings
1051             {% amms (mkTyData (comb4 $1 $3 $5 $6) (snd $ unLoc $1) $2 $3
1052                             (snd $ unLoc $4) (snd $ unLoc $5)
1053                             (fmap reverse $6) )
1054                                    -- We need the location on tycl_hdr in case
1055                                    -- constrs and deriving are both empty
1056                     ((fst $ unLoc $1):(fst $ unLoc $4)++(fst $ unLoc $5)) }
1057
1058           -- data/newtype family
1059         | 'data' 'family' type opt_datafam_kind_sig
1060                 {% amms (mkFamDecl (comb3 $1 $2 $4) DataFamily $3
1061                                    (snd $ unLoc $4) Nothing)
1062                         (mj AnnData $1:mj AnnFamily $2:(fst $ unLoc $4)) }
1063
1064 inst_decl :: { LInstDecl RdrName }
1065         : 'instance' overlap_pragma inst_type where_inst
1066        {% do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc $4)
1067              ; let cid = ClsInstDecl { cid_poly_ty = $3, cid_binds = binds
1068                                      , cid_sigs = mkClassOpSigs sigs
1069                                      , cid_tyfam_insts = ats
1070                                      , cid_overlap_mode = $2
1071                                      , cid_datafam_insts = adts }
1072              ; ams (L (comb3 $1 (hsSigType $3) $4) (ClsInstD { cid_inst = cid }))
1073                    (mj AnnInstance $1 : (fst $ unLoc $4)) } }
1074
1075            -- type instance declarations
1076         | 'type' 'instance' ty_fam_inst_eqn
1077                 {% ams $3 (fst $ unLoc $3)
1078                 >> amms (mkTyFamInst (comb2 $1 $3) (snd $ unLoc $3))
1079                     (mj AnnType $1:mj AnnInstance $2:(fst $ unLoc $3)) }
1080
1081           -- data/newtype instance declaration
1082         | data_or_newtype 'instance' capi_ctype tycl_hdr constrs
1083                           maybe_derivings
1084             {% amms (mkDataFamInst (comb4 $1 $4 $5 $6) (snd $ unLoc $1) $3 $4
1085                                       Nothing (reverse (snd  $ unLoc $5))
1086                                               (fmap reverse $6))
1087                     ((fst $ unLoc $1):mj AnnInstance $2:(fst $ unLoc $5)) }
1088
1089           -- GADT instance declaration
1090         | data_or_newtype 'instance' capi_ctype tycl_hdr opt_kind_sig
1091                  gadt_constrlist
1092                  maybe_derivings
1093             {% amms (mkDataFamInst (comb4 $1 $4 $6 $7) (snd $ unLoc $1) $3 $4
1094                                    (snd $ unLoc $5) (snd $ unLoc $6)
1095                                    (fmap reverse $7))
1096                     ((fst $ unLoc $1):mj AnnInstance $2
1097                        :(fst $ unLoc $5)++(fst $ unLoc $6)) }
1098
1099 overlap_pragma :: { Maybe (Located OverlapMode) }
1100   : '{-# OVERLAPPABLE'    '#-}' {% ajs (Just (sLL $1 $> (Overlappable (getOVERLAPPABLE_PRAGs $1))))
1101                                        [mo $1,mc $2] }
1102   | '{-# OVERLAPPING'     '#-}' {% ajs (Just (sLL $1 $> (Overlapping (getOVERLAPPING_PRAGs $1))))
1103                                        [mo $1,mc $2] }
1104   | '{-# OVERLAPS'        '#-}' {% ajs (Just (sLL $1 $> (Overlaps (getOVERLAPS_PRAGs $1))))
1105                                        [mo $1,mc $2] }
1106   | '{-# INCOHERENT'      '#-}' {% ajs (Just (sLL $1 $> (Incoherent (getINCOHERENT_PRAGs $1))))
1107                                        [mo $1,mc $2] }
1108   | {- empty -}                 { Nothing }
1109
1110 deriv_strategy :: { Maybe (Located DerivStrategy) }
1111   : 'stock'                     {% ajs (Just (sL1 $1 StockStrategy))
1112                                        [mj AnnStock $1] }
1113   | 'anyclass'                  {% ajs (Just (sL1 $1 AnyclassStrategy))
1114                                        [mj AnnAnyclass $1] }
1115   | 'newtype'                   {% ajs (Just (sL1 $1 NewtypeStrategy))
1116                                        [mj AnnNewtype $1] }
1117   | {- empty -}                 { Nothing }
1118
1119 -- Injective type families
1120
1121 opt_injective_info :: { Located ([AddAnn], Maybe (LInjectivityAnn RdrName)) }
1122         : {- empty -}               { noLoc ([], Nothing) }
1123         | '|' injectivity_cond      { sLL $1 $> ([mj AnnVbar $1]
1124                                                 , Just ($2)) }
1125
1126 injectivity_cond :: { LInjectivityAnn RdrName }
1127         : tyvarid '->' inj_varids
1128            {% ams (sLL $1 $> (InjectivityAnn $1 (reverse (unLoc $3))))
1129                   [mu AnnRarrow $2] }
1130
1131 inj_varids :: { Located [Located RdrName] }
1132         : inj_varids tyvarid  { sLL $1 $> ($2 : unLoc $1) }
1133         | tyvarid             { sLL $1 $> [$1]            }
1134
1135 -- Closed type families
1136
1137 where_type_family :: { Located ([AddAnn],FamilyInfo RdrName) }
1138         : {- empty -}                      { noLoc ([],OpenTypeFamily) }
1139         | 'where' ty_fam_inst_eqn_list
1140                { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)
1141                     ,ClosedTypeFamily (fmap reverse $ snd $ unLoc $2)) }
1142
1143 ty_fam_inst_eqn_list :: { Located ([AddAnn],Maybe [LTyFamInstEqn RdrName]) }
1144         :     '{' ty_fam_inst_eqns '}'     { sLL $1 $> ([moc $1,mcc $3]
1145                                                 ,Just (unLoc $2)) }
1146         | vocurly ty_fam_inst_eqns close   { let L loc _ = $2 in
1147                                              L loc ([],Just (unLoc $2)) }
1148         |     '{' '..' '}'                 { sLL $1 $> ([moc $1,mj AnnDotdot $2
1149                                                  ,mcc $3],Nothing) }
1150         | vocurly '..' close               { let L loc _ = $2 in
1151                                              L loc ([mj AnnDotdot $2],Nothing) }
1152
1153 ty_fam_inst_eqns :: { Located [LTyFamInstEqn RdrName] }
1154         : ty_fam_inst_eqns ';' ty_fam_inst_eqn
1155                                       {% asl (unLoc $1) $2 (snd $ unLoc $3)
1156                                          >> ams $3 (fst $ unLoc $3)
1157                                          >> return (sLL $1 $> ((snd $ unLoc $3) : unLoc $1)) }
1158         | ty_fam_inst_eqns ';'        {% addAnnotation (gl $1) AnnSemi (gl $2)
1159                                          >> return (sLL $1 $>  (unLoc $1)) }
1160         | ty_fam_inst_eqn             {% ams $1 (fst $ unLoc $1)
1161                                          >> return (sLL $1 $> [snd $ unLoc $1]) }
1162         | {- empty -}                 { noLoc [] }
1163
1164 ty_fam_inst_eqn :: { Located ([AddAnn],LTyFamInstEqn RdrName) }
1165         : type '=' ctype
1166                 -- Note the use of type for the head; this allows
1167                 -- infix type constructors and type patterns
1168               {% do { (eqn,ann) <- mkTyFamInstEqn $1 $3
1169                     ; return (sLL $1 $> (mj AnnEqual $2:ann, sLL $1 $> eqn))  } }
1170
1171 -- Associated type family declarations
1172 --
1173 -- * They have a different syntax than on the toplevel (no family special
1174 --   identifier).
1175 --
1176 -- * They also need to be separate from instances; otherwise, data family
1177 --   declarations without a kind signature cause parsing conflicts with empty
1178 --   data declarations.
1179 --
1180 at_decl_cls :: { LHsDecl RdrName }
1181         :  -- data family declarations, with optional 'family' keyword
1182           'data' opt_family type opt_datafam_kind_sig
1183                 {% amms (liftM mkTyClD (mkFamDecl (comb3 $1 $3 $4) DataFamily $3
1184                                                   (snd $ unLoc $4) Nothing))
1185                         (mj AnnData $1:$2++(fst $ unLoc $4)) }
1186
1187            -- type family declarations, with optional 'family' keyword
1188            -- (can't use opt_instance because you get shift/reduce errors
1189         | 'type' type opt_at_kind_inj_sig
1190                {% amms (liftM mkTyClD
1191                         (mkFamDecl (comb3 $1 $2 $3) OpenTypeFamily $2
1192                                    (fst . snd $ unLoc $3)
1193                                    (snd . snd $ unLoc $3)))
1194                        (mj AnnType $1:(fst $ unLoc $3)) }
1195         | 'type' 'family' type opt_at_kind_inj_sig
1196                {% amms (liftM mkTyClD
1197                         (mkFamDecl (comb3 $1 $3 $4) OpenTypeFamily $3
1198                                    (fst . snd $ unLoc $4)
1199                                    (snd . snd $ unLoc $4)))
1200                        (mj AnnType $1:mj AnnFamily $2:(fst $ unLoc $4)) }
1201
1202            -- default type instances, with optional 'instance' keyword
1203         | 'type' ty_fam_inst_eqn
1204                 {% ams $2 (fst $ unLoc $2) >>
1205                    amms (liftM mkInstD (mkTyFamInst (comb2 $1 $2) (snd $ unLoc $2)))
1206                         (mj AnnType $1:(fst $ unLoc $2)) }
1207         | 'type' 'instance' ty_fam_inst_eqn
1208                 {% ams $3 (fst $ unLoc $3) >>
1209                    amms (liftM mkInstD (mkTyFamInst (comb2 $1 $3) (snd $ unLoc $3)))
1210                         (mj AnnType $1:mj AnnInstance $2:(fst $ unLoc $3)) }
1211
1212 opt_family   :: { [AddAnn] }
1213               : {- empty -}   { [] }
1214               | 'family'      { [mj AnnFamily $1] }
1215
1216 -- Associated type instances
1217 --
1218 at_decl_inst :: { LInstDecl RdrName }
1219            -- type instance declarations
1220         : 'type' ty_fam_inst_eqn
1221                 -- Note the use of type for the head; this allows
1222                 -- infix type constructors and type patterns
1223                 {% ams $2 (fst $ unLoc $2) >>
1224                    amms (mkTyFamInst (comb2 $1 $2) (snd $ unLoc $2))
1225                         (mj AnnType $1:(fst $ unLoc $2)) }
1226
1227         -- data/newtype instance declaration
1228         | data_or_newtype capi_ctype tycl_hdr constrs maybe_derivings
1229                {% amms (mkDataFamInst (comb4 $1 $3 $4 $5) (snd $ unLoc $1) $2 $3
1230                                     Nothing (reverse (snd $ unLoc $4))
1231                                             (fmap reverse $5))
1232                        ((fst $ unLoc $1):(fst $ unLoc $4)) }
1233
1234         -- GADT instance declaration
1235         | data_or_newtype capi_ctype tycl_hdr opt_kind_sig
1236                  gadt_constrlist
1237                  maybe_derivings
1238                 {% amms (mkDataFamInst (comb4 $1 $3 $5 $6) (snd $ unLoc $1) $2
1239                                 $3 (snd $ unLoc $4) (snd $ unLoc $5)
1240                                 (fmap reverse $6))
1241                         ((fst $ unLoc $1):(fst $ unLoc $4)++(fst $ unLoc $5)) }
1242
1243 data_or_newtype :: { Located (AddAnn, NewOrData) }
1244         : 'data'        { sL1 $1 (mj AnnData    $1,DataType) }
1245         | 'newtype'     { sL1 $1 (mj AnnNewtype $1,NewType) }
1246
1247 -- Family result/return kind signatures
1248
1249 opt_kind_sig :: { Located ([AddAnn], Maybe (LHsKind RdrName)) }
1250         :               { noLoc     ([]               , Nothing) }
1251         | '::' kind     { sLL $1 $> ([mu AnnDcolon $1], Just $2) }
1252
1253 opt_datafam_kind_sig :: { Located ([AddAnn], LFamilyResultSig RdrName) }
1254         :               { noLoc     ([]               , noLoc NoSig           )}
1255         | '::' kind     { sLL $1 $> ([mu AnnDcolon $1], sLL $1 $> (KindSig $2))}
1256
1257 opt_tyfam_kind_sig :: { Located ([AddAnn], LFamilyResultSig RdrName) }
1258         :              { noLoc     ([]               , noLoc      NoSig       )}
1259         | '::' kind    { sLL $1 $> ([mu AnnDcolon $1], sLL $1 $> (KindSig  $2))}
1260         | '='  tv_bndr { sLL $1 $> ([mj AnnEqual $1] , sLL $1 $> (TyVarSig $2))}
1261
1262 opt_at_kind_inj_sig :: { Located ([AddAnn], ( LFamilyResultSig RdrName
1263                                             , Maybe (LInjectivityAnn RdrName)))}
1264         :            { noLoc ([], (noLoc NoSig, Nothing)) }
1265         | '::' kind  { sLL $1 $> ( [mu AnnDcolon $1]
1266                                  , (sLL $2 $> (KindSig $2), Nothing)) }
1267         | '='  tv_bndr '|' injectivity_cond
1268                 { sLL $1 $> ([mj AnnEqual $1, mj AnnVbar $3]
1269                             , (sLL $1 $2 (TyVarSig $2), Just $4))}
1270
1271 -- tycl_hdr parses the header of a class or data type decl,
1272 -- which takes the form
1273 --      T a b
1274 --      Eq a => T a
1275 --      (Eq a, Ord b) => T a b
1276 --      T Int [a]                       -- for associated types
1277 -- Rather a lot of inlining here, else we get reduce/reduce errors
1278 tycl_hdr :: { Located (Maybe (LHsContext RdrName), LHsType RdrName) }
1279         : context '=>' type         {% addAnnotation (gl $1) (toUnicodeAnn AnnDarrow $2) (gl $2)
1280                                        >> (return (sLL $1 $> (Just $1, $3)))
1281                                     }
1282         | type                      { sL1 $1 (Nothing, $1) }
1283
1284 capi_ctype :: { Maybe (Located CType) }
1285 capi_ctype : '{-# CTYPE' STRING STRING '#-}'
1286                        {% ajs (Just (sLL $1 $> (CType (getCTYPEs $1) (Just (Header (getSTRINGs $2) (getSTRING $2)))
1287                                         (getSTRINGs $3,getSTRING $3))))
1288                               [mo $1,mj AnnHeader $2,mj AnnVal $3,mc $4] }
1289
1290            | '{-# CTYPE'        STRING '#-}'
1291                        {% ajs (Just (sLL $1 $> (CType (getCTYPEs $1) Nothing  (getSTRINGs $2, getSTRING $2))))
1292                               [mo $1,mj AnnVal $2,mc $3] }
1293
1294            |           { Nothing }
1295
1296 -----------------------------------------------------------------------------
1297 -- Stand-alone deriving
1298
1299 -- Glasgow extension: stand-alone deriving declarations
1300 stand_alone_deriving :: { LDerivDecl RdrName }
1301   : 'deriving' deriv_strategy 'instance' overlap_pragma inst_type
1302                 {% do { let { err = text "in the stand-alone deriving instance"
1303                                     <> colon <+> quotes (ppr $5) }
1304                       ; ams (sLL $1 (hsSigType $>) (DerivDecl $5 $2 $4))
1305                             [mj AnnDeriving $1, mj AnnInstance $3] } }
1306
1307 -----------------------------------------------------------------------------
1308 -- Role annotations
1309
1310 role_annot :: { LRoleAnnotDecl RdrName }
1311 role_annot : 'type' 'role' oqtycon maybe_roles
1312           {% amms (mkRoleAnnotDecl (comb3 $1 $3 $4) $3 (reverse (unLoc $4)))
1313                   [mj AnnType $1,mj AnnRole $2] }
1314
1315 -- Reversed!
1316 maybe_roles :: { Located [Located (Maybe FastString)] }
1317 maybe_roles : {- empty -}    { noLoc [] }
1318             | roles          { $1 }
1319
1320 roles :: { Located [Located (Maybe FastString)] }
1321 roles : role             { sLL $1 $> [$1] }
1322       | roles role       { sLL $1 $> $ $2 : unLoc $1 }
1323
1324 -- read it in as a varid for better error messages
1325 role :: { Located (Maybe FastString) }
1326 role : VARID             { sL1 $1 $ Just $ getVARID $1 }
1327      | '_'               { sL1 $1 Nothing }
1328
1329 -- Pattern synonyms
1330
1331 -- Glasgow extension: pattern synonyms
1332 pattern_synonym_decl :: { LHsDecl RdrName }
1333         : 'pattern' pattern_synonym_lhs '=' pat
1334          {%      let (name, args,as ) = $2 in
1335                  ams (sLL $1 $> . ValD $ mkPatSynBind name args $4
1336                                                     ImplicitBidirectional)
1337                (as ++ [mj AnnPattern $1, mj AnnEqual $3])
1338          }
1339
1340         | 'pattern' pattern_synonym_lhs '<-' pat
1341          {%    let (name, args, as) = $2 in
1342                ams (sLL $1 $> . ValD $ mkPatSynBind name args $4 Unidirectional)
1343                (as ++ [mj AnnPattern $1,mu AnnLarrow $3]) }
1344
1345         | 'pattern' pattern_synonym_lhs '<-' pat where_decls
1346             {% do { let (name, args, as) = $2
1347                   ; mg <- mkPatSynMatchGroup name (snd $ unLoc $5)
1348                   ; ams (sLL $1 $> . ValD $
1349                            mkPatSynBind name args $4 (ExplicitBidirectional mg))
1350                        (as ++ ((mj AnnPattern $1:mu AnnLarrow $3:(fst $ unLoc $5))) )
1351                    }}
1352
1353 pattern_synonym_lhs :: { (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]) }
1354         : con vars0 { ($1, PrefixPatSyn $2, []) }
1355         | varid conop varid { ($2, InfixPatSyn $1 $3, []) }
1356         | con '{' cvars1 '}' { ($1, RecordPatSyn $3, [moc $2, mcc $4] ) }
1357
1358 vars0 :: { [Located RdrName] }
1359         : {- empty -}                 { [] }
1360         | varid vars0                 { $1 : $2 }
1361
1362 cvars1 :: { [RecordPatSynField (Located RdrName)] }
1363        : varid                        { [RecordPatSynField $1 $1] }
1364        | varid ',' cvars1             {% addAnnotation (getLoc $1) AnnComma (getLoc $2) >>
1365                                          return ((RecordPatSynField $1 $1) : $3 )}
1366
1367 where_decls :: { Located ([AddAnn]
1368                          , Located (OrdList (LHsDecl RdrName))) }
1369         : 'where' '{' decls '}'       { sLL $1 $> ((mj AnnWhere $1:moc $2
1370                                            :mcc $4:(fst $ unLoc $3)),sL1 $3 (snd $ unLoc $3)) }
1371         | 'where' vocurly decls close { L (comb2 $1 $3) ((mj AnnWhere $1:(fst $ unLoc $3))
1372                                           ,sL1 $3 (snd $ unLoc $3)) }
1373
1374 pattern_synonym_sig :: { LSig RdrName }
1375         : 'pattern' con_list '::' sigtype
1376                    {% ams (sLL $1 $> $ PatSynSig (unLoc $2) (mkLHsSigType $4))
1377                           [mj AnnPattern $1, mu AnnDcolon $3] }
1378
1379 -----------------------------------------------------------------------------
1380 -- Nested declarations
1381
1382 -- Declaration in class bodies
1383 --
1384 decl_cls  :: { LHsDecl RdrName }
1385 decl_cls  : at_decl_cls                 { $1 }
1386           | decl                        { $1 }
1387
1388           -- A 'default' signature used with the generic-programming extension
1389           | 'default' infixexp '::' sigtypedoc
1390                     {% do { v <- checkValSigLhs $2
1391                           ; let err = text "in default signature" <> colon <+>
1392                                       quotes (ppr $2)
1393                           ; ams (sLL $1 $> $ SigD $ ClassOpSig True [v] $ mkLHsSigType $4)
1394                                 [mj AnnDefault $1,mu AnnDcolon $3] } }
1395
1396 decls_cls :: { Located ([AddAnn],OrdList (LHsDecl RdrName)) }  -- Reversed
1397           : decls_cls ';' decl_cls      {% if isNilOL (snd $ unLoc $1)
1398                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1399                                                                     , unitOL $3))
1400                                              else ams (lastOL (snd $ unLoc $1)) [mj AnnSemi $2]
1401                                            >> return (sLL $1 $> (fst $ unLoc $1
1402                                                                 ,(snd $ unLoc $1) `appOL` unitOL $3)) }
1403           | decls_cls ';'               {% if isNilOL (snd $ unLoc $1)
1404                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1405                                                                                    ,snd $ unLoc $1))
1406                                              else ams (lastOL (snd $ unLoc $1)) [mj AnnSemi $2]
1407                                            >> return (sLL $1 $>  (unLoc $1)) }
1408           | decl_cls                    { sL1 $1 ([], unitOL $1) }
1409           | {- empty -}                 { noLoc ([],nilOL) }
1410
1411 decllist_cls
1412         :: { Located ([AddAnn]
1413                      , OrdList (LHsDecl RdrName)) }      -- Reversed
1414         : '{'         decls_cls '}'     { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2)
1415                                              ,snd $ unLoc $2) }
1416         |     vocurly decls_cls close   { $2 }
1417
1418 -- Class body
1419 --
1420 where_cls :: { Located ([AddAnn]
1421                        ,(OrdList (LHsDecl RdrName))) }    -- Reversed
1422                                 -- No implicit parameters
1423                                 -- May have type declarations
1424         : 'where' decllist_cls          { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)
1425                                              ,snd $ unLoc $2) }
1426         | {- empty -}                   { noLoc ([],nilOL) }
1427
1428 -- Declarations in instance bodies
1429 --
1430 decl_inst  :: { Located (OrdList (LHsDecl RdrName)) }
1431 decl_inst  : at_decl_inst               { sLL $1 $> (unitOL (sL1 $1 (InstD (unLoc $1)))) }
1432            | decl                       { sLL $1 $> (unitOL $1) }
1433
1434 decls_inst :: { Located ([AddAnn],OrdList (LHsDecl RdrName)) }   -- Reversed
1435            : decls_inst ';' decl_inst   {% if isNilOL (snd $ unLoc $1)
1436                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1437                                                                     , unLoc $3))
1438                                              else ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1439                                            >> return
1440                                             (sLL $1 $> (fst $ unLoc $1
1441                                                        ,(snd $ unLoc $1) `appOL` unLoc $3)) }
1442            | decls_inst ';'             {% if isNilOL (snd $ unLoc $1)
1443                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1444                                                                                    ,snd $ unLoc $1))
1445                                              else ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1446                                            >> return (sLL $1 $> (unLoc $1)) }
1447            | decl_inst                  { sL1 $1 ([],unLoc $1) }
1448            | {- empty -}                { noLoc ([],nilOL) }
1449
1450 decllist_inst
1451         :: { Located ([AddAnn]
1452                      , OrdList (LHsDecl RdrName)) }      -- Reversed
1453         : '{'         decls_inst '}'    { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2),snd $ unLoc $2) }
1454         |     vocurly decls_inst close  { L (gl $2) (unLoc $2) }
1455
1456 -- Instance body
1457 --
1458 where_inst :: { Located ([AddAnn]
1459                         , OrdList (LHsDecl RdrName)) }   -- Reversed
1460                                 -- No implicit parameters
1461                                 -- May have type declarations
1462         : 'where' decllist_inst         { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)
1463                                              ,(snd $ unLoc $2)) }
1464         | {- empty -}                   { noLoc ([],nilOL) }
1465
1466 -- Declarations in binding groups other than classes and instances
1467 --
1468 decls   :: { Located ([AddAnn],OrdList (LHsDecl RdrName)) }
1469         : decls ';' decl    {% if isNilOL (snd $ unLoc $1)
1470                                  then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1471                                                         , unitOL $3))
1472                                  else do ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1473                                            >> return (
1474                                           let { this = unitOL $3;
1475                                                 rest = snd $ unLoc $1;
1476                                                 these = rest `appOL` this }
1477                                           in rest `seq` this `seq` these `seq`
1478                                              (sLL $1 $> (fst $ unLoc $1,these))) }
1479         | decls ';'          {% if isNilOL (snd $ unLoc $1)
1480                                   then return (sLL $1 $> ((mj AnnSemi $2:(fst $ unLoc $1)
1481                                                           ,snd $ unLoc $1)))
1482                                   else ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1483                                            >> return (sLL $1 $> (unLoc $1)) }
1484         | decl                          { sL1 $1 ([], unitOL $1) }
1485         | {- empty -}                   { noLoc ([],nilOL) }
1486
1487 decllist :: { Located ([AddAnn],Located (OrdList (LHsDecl RdrName))) }
1488         : '{'            decls '}'     { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2)
1489                                                    ,sL1 $2 $ snd $ unLoc $2) }
1490         |     vocurly    decls close   { L (gl $2) (fst $ unLoc $2,sL1 $2 $ snd $ unLoc $2) }
1491
1492 -- Binding groups other than those of class and instance declarations
1493 --
1494 binds   ::  { Located ([AddAnn],Located (HsLocalBinds RdrName)) }
1495                                          -- May have implicit parameters
1496                                                 -- No type declarations
1497         : decllist          {% do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc $1)
1498                                   ; return (sL1 $1 (fst $ unLoc $1
1499                                                     ,sL1 $1 $ HsValBinds val_binds)) } }
1500
1501         | '{'            dbinds '}'     { sLL $1 $> ([moc $1,mcc $3]
1502                                              ,sL1 $2 $ HsIPBinds (IPBinds (reverse $ unLoc $2)
1503                                                          emptyTcEvBinds)) }
1504
1505         |     vocurly    dbinds close   { L (getLoc $2) ([]
1506                                             ,sL1 $2 $ HsIPBinds (IPBinds (reverse $ unLoc $2)
1507                                                         emptyTcEvBinds)) }
1508
1509
1510 wherebinds :: { Located ([AddAnn],Located (HsLocalBinds RdrName)) }
1511                                                 -- May have implicit parameters
1512                                                 -- No type declarations
1513         : 'where' binds                 { sLL $1 $> (mj AnnWhere $1 : (fst $ unLoc $2)
1514                                              ,snd $ unLoc $2) }
1515         | {- empty -}                   { noLoc ([],noLoc emptyLocalBinds) }
1516
1517
1518 -----------------------------------------------------------------------------
1519 -- Transformation Rules
1520
1521 rules   :: { OrdList (LRuleDecl RdrName) }
1522         :  rules ';' rule              {% addAnnotation (oll $1) AnnSemi (gl $2)
1523                                           >> return ($1 `snocOL` $3) }
1524         |  rules ';'                   {% addAnnotation (oll $1) AnnSemi (gl $2)
1525                                           >> return $1 }
1526         |  rule                        { unitOL $1 }
1527         |  {- empty -}                 { nilOL }
1528
1529 rule    :: { LRuleDecl RdrName }
1530         : STRING rule_activation rule_forall infixexp '=' exp
1531          {%ams (sLL $1 $> $ (HsRule (L (gl $1) (getSTRINGs $1,getSTRING $1))
1532                                   ((snd $2) `orElse` AlwaysActive)
1533                                   (snd $3) $4 placeHolderNames $6
1534                                   placeHolderNames))
1535                (mj AnnEqual $5 : (fst $2) ++ (fst $3)) }
1536
1537 -- Rules can be specified to be NeverActive, unlike inline/specialize pragmas
1538 rule_activation :: { ([AddAnn],Maybe Activation) }
1539         : {- empty -}                           { ([],Nothing) }
1540         | rule_explicit_activation              { (fst $1,Just (snd $1)) }
1541
1542 rule_explicit_activation :: { ([AddAnn]
1543                               ,Activation) }  -- In brackets
1544         : '[' INTEGER ']'       { ([mos $1,mj AnnVal $2,mcs $3]
1545                                   ,ActiveAfter  (getINTEGERs $2) (fromInteger (getINTEGER $2))) }
1546         | '[' '~' INTEGER ']'   { ([mos $1,mj AnnTilde $2,mj AnnVal $3,mcs $4]
1547                                   ,ActiveBefore (getINTEGERs $3) (fromInteger (getINTEGER $3))) }
1548         | '[' '~' ']'           { ([mos $1,mj AnnTilde $2,mcs $3]
1549                                   ,NeverActive) }
1550
1551 rule_forall :: { ([AddAnn],[LRuleBndr RdrName]) }
1552         : 'forall' rule_var_list '.'     { ([mu AnnForall $1,mj AnnDot $3],$2) }
1553         | {- empty -}                    { ([],[]) }
1554
1555 rule_var_list :: { [LRuleBndr RdrName] }
1556         : rule_var                              { [$1] }
1557         | rule_var rule_var_list                { $1 : $2 }
1558
1559 rule_var :: { LRuleBndr RdrName }
1560         : varid                         { sLL $1 $> (RuleBndr $1) }
1561         | '(' varid '::' ctype ')'      {% ams (sLL $1 $> (RuleBndrSig $2
1562                                                        (mkLHsSigWcType $4)))
1563                                                [mop $1,mu AnnDcolon $3,mcp $5] }
1564
1565 -----------------------------------------------------------------------------
1566 -- Warnings and deprecations (c.f. rules)
1567
1568 warnings :: { OrdList (LWarnDecl RdrName) }
1569         : warnings ';' warning         {% addAnnotation (oll $1) AnnSemi (gl $2)
1570                                           >> return ($1 `appOL` $3) }
1571         | warnings ';'                 {% addAnnotation (oll $1) AnnSemi (gl $2)
1572                                           >> return $1 }
1573         | warning                      { $1 }
1574         | {- empty -}                  { nilOL }
1575
1576 -- SUP: TEMPORARY HACK, not checking for `module Foo'
1577 warning :: { OrdList (LWarnDecl RdrName) }
1578         : namelist strings
1579                 {% amsu (sLL $1 $> (Warning (unLoc $1) (WarningTxt (noLoc NoSourceText) $ snd $ unLoc $2)))
1580                      (fst $ unLoc $2) }
1581
1582 deprecations :: { OrdList (LWarnDecl RdrName) }
1583         : deprecations ';' deprecation
1584                                        {% addAnnotation (oll $1) AnnSemi (gl $2)
1585                                           >> return ($1 `appOL` $3) }
1586         | deprecations ';'             {% addAnnotation (oll $1) AnnSemi (gl $2)
1587                                           >> return $1 }
1588         | deprecation                  { $1 }
1589         | {- empty -}                  { nilOL }
1590
1591 -- SUP: TEMPORARY HACK, not checking for `module Foo'
1592 deprecation :: { OrdList (LWarnDecl RdrName) }
1593         : namelist strings
1594              {% amsu (sLL $1 $> $ (Warning (unLoc $1) (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc $2)))
1595                      (fst $ unLoc $2) }
1596
1597 strings :: { Located ([AddAnn],[Located StringLiteral]) }
1598     : STRING { sL1 $1 ([],[L (gl $1) (getStringLiteral $1)]) }
1599     | '[' stringlist ']' { sLL $1 $> $ ([mos $1,mcs $3],fromOL (unLoc $2)) }
1600
1601 stringlist :: { Located (OrdList (Located StringLiteral)) }
1602     : stringlist ',' STRING {% addAnnotation (oll $ unLoc $1) AnnComma (gl $2) >>
1603                                return (sLL $1 $> (unLoc $1 `snocOL`
1604                                                   (L (gl $3) (getStringLiteral $3)))) }
1605     | STRING                { sLL $1 $> (unitOL (L (gl $1) (getStringLiteral $1))) }
1606     | {- empty -}           { noLoc nilOL }
1607
1608 -----------------------------------------------------------------------------
1609 -- Annotations
1610 annotation :: { LHsDecl RdrName }
1611     : '{-# ANN' name_var aexp '#-}'      {% ams (sLL $1 $> (AnnD $ HsAnnotation
1612                                             (getANN_PRAGs $1)
1613                                             (ValueAnnProvenance $2) $3))
1614                                             [mo $1,mc $4] }
1615
1616     | '{-# ANN' 'type' tycon aexp '#-}'  {% ams (sLL $1 $> (AnnD $ HsAnnotation
1617                                             (getANN_PRAGs $1)
1618                                             (TypeAnnProvenance $3) $4))
1619                                             [mo $1,mj AnnType $2,mc $5] }
1620
1621     | '{-# ANN' 'module' aexp '#-}'      {% ams (sLL $1 $> (AnnD $ HsAnnotation
1622                                                 (getANN_PRAGs $1)
1623                                                  ModuleAnnProvenance $3))
1624                                                 [mo $1,mj AnnModule $2,mc $4] }
1625
1626
1627 -----------------------------------------------------------------------------
1628 -- Foreign import and export declarations
1629
1630 fdecl :: { Located ([AddAnn],HsDecl RdrName) }
1631 fdecl : 'import' callconv safety fspec
1632                {% mkImport $2 $3 (snd $ unLoc $4) >>= \i ->
1633                  return (sLL $1 $> (mj AnnImport $1 : (fst $ unLoc $4),i))  }
1634       | 'import' callconv        fspec
1635                {% do { d <- mkImport $2 (noLoc PlaySafe) (snd $ unLoc $3);
1636                     return (sLL $1 $> (mj AnnImport $1 : (fst $ unLoc $3),d)) }}
1637       | 'export' callconv fspec
1638                {% mkExport $2 (snd $ unLoc $3) >>= \i ->
1639                   return (sLL $1 $> (mj AnnExport $1 : (fst $ unLoc $3),i) ) }
1640
1641 callconv :: { Located CCallConv }
1642           : 'stdcall'                   { sLL $1 $> StdCallConv }
1643           | 'ccall'                     { sLL $1 $> CCallConv   }
1644           | 'capi'                      { sLL $1 $> CApiConv    }
1645           | 'prim'                      { sLL $1 $> PrimCallConv}
1646           | 'javascript'                { sLL $1 $> JavaScriptCallConv }
1647
1648 safety :: { Located Safety }
1649         : 'unsafe'                      { sLL $1 $> PlayRisky }
1650         | 'safe'                        { sLL $1 $> PlaySafe }
1651         | 'interruptible'               { sLL $1 $> PlayInterruptible }
1652
1653 fspec :: { Located ([AddAnn]
1654                     ,(Located StringLiteral, Located RdrName, LHsSigType RdrName)) }
1655        : STRING var '::' sigtypedoc     { sLL $1 $> ([mu AnnDcolon $3]
1656                                              ,(L (getLoc $1)
1657                                                     (getStringLiteral $1), $2, mkLHsSigType $4)) }
1658        |        var '::' sigtypedoc     { sLL $1 $> ([mu AnnDcolon $2]
1659                                              ,(noLoc (StringLiteral NoSourceText nilFS), $1, mkLHsSigType $3)) }
1660          -- if the entity string is missing, it defaults to the empty string;
1661          -- the meaning of an empty entity string depends on the calling
1662          -- convention
1663
1664 -----------------------------------------------------------------------------
1665 -- Type signatures
1666
1667 opt_sig :: { ([AddAnn], Maybe (LHsType RdrName)) }
1668         : {- empty -}                   { ([],Nothing) }
1669         | '::' sigtype                  { ([mu AnnDcolon $1],Just $2) }
1670
1671 opt_asig :: { ([AddAnn],Maybe (LHsType RdrName)) }
1672         : {- empty -}                   { ([],Nothing) }
1673         | '::' atype                    { ([mu AnnDcolon $1],Just $2) }
1674
1675 sigtype :: { LHsType RdrName }
1676         : ctype                            { $1 }
1677
1678 sigtypedoc :: { LHsType RdrName }
1679         : ctypedoc                         { $1 }
1680
1681
1682 sig_vars :: { Located [Located RdrName] }    -- Returned in reversed order
1683          : sig_vars ',' var           {% addAnnotation (gl $ head $ unLoc $1)
1684                                                        AnnComma (gl $2)
1685                                          >> return (sLL $1 $> ($3 : unLoc $1)) }
1686          | var                        { sL1 $1 [$1] }
1687
1688 sigtypes1 :: { (OrdList (LHsSigType RdrName)) }
1689    : sigtype                 { unitOL (mkLHsSigType $1) }
1690    | sigtype ',' sigtypes1   {% addAnnotation (gl $1) AnnComma (gl $2)
1691                                 >> return (unitOL (mkLHsSigType $1) `appOL` $3) }
1692
1693 -----------------------------------------------------------------------------
1694 -- Types
1695
1696 strict_mark :: { Located ([AddAnn],HsSrcBang) }
1697         : strictness { sL1 $1 (let (a, str) = unLoc $1 in (a, HsSrcBang NoSourceText NoSrcUnpack str)) }
1698         | unpackedness { sL1 $1 (let (a, prag, unpk) = unLoc $1 in (a, HsSrcBang prag unpk NoSrcStrict)) }
1699         | unpackedness strictness { sLL $1 $> (let { (a, prag, unpk) = unLoc $1
1700                                                    ; (a', str) = unLoc $2 }
1701                                                 in (a ++ a', HsSrcBang prag unpk str)) }
1702         -- Although UNPACK with no '!' without StrictData and UNPACK with '~' are illegal,
1703         -- we get a better error message if we parse them here
1704
1705 strictness :: { Located ([AddAnn], SrcStrictness) }
1706         : '!' { sL1 $1 ([mj AnnBang $1], SrcStrict) }
1707         | '~' { sL1 $1 ([mj AnnTilde $1], SrcLazy) }
1708
1709 unpackedness :: { Located ([AddAnn], SourceText, SrcUnpackedness) }
1710         : '{-# UNPACK' '#-}'   { sLL $1 $> ([mo $1, mc $2], getUNPACK_PRAGs $1, SrcUnpack) }
1711         | '{-# NOUNPACK' '#-}' { sLL $1 $> ([mo $1, mc $2], getNOUNPACK_PRAGs $1, SrcNoUnpack) }
1712
1713 -- A ctype is a for-all type
1714 ctype   :: { LHsType RdrName }
1715         : 'forall' tv_bndrs '.' ctype   {% hintExplicitForall (getLoc $1) >>
1716                                            ams (sLL $1 $> $
1717                                                 HsForAllTy { hst_bndrs = $2
1718                                                            , hst_body = $4 })
1719                                                [mu AnnForall $1, mj AnnDot $3] }
1720         | context '=>' ctype          {% addAnnotation (gl $1) (toUnicodeAnn AnnDarrow $2) (gl $2)
1721                                          >> return (sLL $1 $> $
1722                                             HsQualTy { hst_ctxt = $1
1723                                                      , hst_body = $3 }) }
1724         | ipvar '::' type             {% ams (sLL $1 $> (HsIParamTy $1 $3))
1725                                              [mu AnnDcolon $2] }
1726         | type                        { $1 }
1727
1728 ----------------------
1729 -- Notes for 'ctypedoc'
1730 -- It would have been nice to simplify the grammar by unifying `ctype` and
1731 -- ctypedoc` into one production, allowing comments on types everywhere (and
1732 -- rejecting them after parsing, where necessary).  This is however not possible
1733 -- since it leads to ambiguity. The reason is the support for comments on record
1734 -- fields:
1735 --         data R = R { field :: Int -- ^ comment on the field }
1736 -- If we allow comments on types here, it's not clear if the comment applies
1737 -- to 'field' or to 'Int'. So we must use `ctype` to describe the type.
1738
1739 ctypedoc :: { LHsType RdrName }
1740         : 'forall' tv_bndrs '.' ctypedoc {% hintExplicitForall (getLoc $1) >>
1741                                             ams (sLL $1 $> $
1742                                                  HsForAllTy { hst_bndrs = $2
1743                                                             , hst_body = $4 })
1744                                                 [mu AnnForall $1,mj AnnDot $3] }
1745         | context '=>' ctypedoc       {% addAnnotation (gl $1) (toUnicodeAnn AnnDarrow $2) (gl $2)
1746                                          >> return (sLL $1 $> $
1747                                             HsQualTy { hst_ctxt = $1
1748                                                      , hst_body = $3 }) }
1749         | ipvar '::' type             {% ams (sLL $1 $> (HsIParamTy $1 $3))
1750                                              [mu AnnDcolon $2] }
1751         | typedoc                     { $1 }
1752
1753 ----------------------
1754 -- Notes for 'context'
1755 -- We parse a context as a btype so that we don't get reduce/reduce
1756 -- errors in ctype.  The basic problem is that
1757 --      (Eq a, Ord a)
1758 -- looks so much like a tuple type.  We can't tell until we find the =>
1759
1760 -- We have the t1 ~ t2 form both in 'context' and in type,
1761 -- to permit an individual equational constraint without parenthesis.
1762 -- Thus for some reason we allow    f :: a~b => blah
1763 -- but not                          f :: ?x::Int => blah
1764 -- See Note [Parsing ~]
1765 context :: { LHsContext RdrName }
1766         :  btype                        {% do { (anns,ctx) <- checkContext $1
1767                                                 ; if null (unLoc ctx)
1768                                                    then addAnnotation (gl $1) AnnUnit (gl $1)
1769                                                    else return ()
1770                                                 ; ams ctx anns
1771                                                 } }
1772
1773 context_no_ops :: { LHsContext RdrName }
1774         : btype_no_ops                 {% do { ty <- splitTilde $1
1775                                              ; (anns,ctx) <- checkContext ty
1776                                              ; if null (unLoc ctx)
1777                                                    then addAnnotation (gl ty) AnnUnit (gl ty)
1778                                                    else return ()
1779                                              ; ams ctx anns
1780                                              } }
1781
1782 {- Note [GADT decl discards annotations]
1783 ~~~~~~~~~~~~~~~~~~~~~
1784 The type production for
1785
1786     btype `->` btype
1787
1788 adds the AnnRarrow annotation twice, in different places.
1789
1790 This is because if the type is processed as usual, it belongs on the annotations
1791 for the type as a whole.
1792
1793 But if the type is passed to mkGadtDecl, it discards the top level SrcSpan, and
1794 the top-level annotation will be disconnected. Hence for this specific case it
1795 is connected to the first type too.
1796 -}
1797
1798 type :: { LHsType RdrName }
1799         : btype                        { $1 }
1800         | btype '->' ctype             {% ams $1 [mu AnnRarrow $2] -- See note [GADT decl discards annotations]
1801                                        >> ams (sLL $1 $> $ HsFunTy $1 $3)
1802                                               [mu AnnRarrow $2] }
1803
1804
1805 typedoc :: { LHsType RdrName }
1806         : btype                          { $1 }
1807         | btype docprev                  { sLL $1 $> $ HsDocTy $1 $2 }
1808         | btype '->'     ctypedoc        {% ams (sLL $1 $> $ HsFunTy $1 $3)
1809                                                 [mu AnnRarrow $2] }
1810         | btype docprev '->' ctypedoc    {% ams (sLL $1 $> $
1811                                                  HsFunTy (L (comb2 $1 $2) (HsDocTy $1 $2))
1812                                                          $4)
1813                                                 [mu AnnRarrow $3] }
1814
1815 -- See Note [Parsing ~]
1816 btype :: { LHsType RdrName }
1817         : tyapps                      {%  splitTildeApps (reverse (unLoc $1)) >>=
1818                                           \ts -> return $ sL1 $1 $ HsAppsTy ts }
1819
1820 -- Used for parsing Haskell98-style data constructors,
1821 -- in order to forbid the blasphemous
1822 -- > data Foo = Int :+ Char :* Bool
1823 -- See also Note [Parsing data constructors is hard] in RdrHsSyn
1824 btype_no_ops :: { LHsType RdrName }
1825         : btype_no_ops atype            { sLL $1 $> $ HsAppTy $1 $2 }
1826         | atype                         { $1 }
1827
1828 tyapps :: { Located [LHsAppType RdrName] }   -- NB: This list is reversed
1829         : tyapp                         { sL1 $1 [$1] }
1830         | tyapps tyapp                  { sLL $1 $> $ $2 : (unLoc $1) }
1831
1832 -- See Note [HsAppsTy] in HsTypes
1833 tyapp :: { LHsAppType RdrName }
1834         : atype                         { sL1 $1 $ HsAppPrefix $1 }
1835         | qtyconop                      { sL1 $1 $ HsAppInfix $1 }
1836         | tyvarop                       { sL1 $1 $ HsAppInfix $1 }
1837         | SIMPLEQUOTE qconop            {% ams (sLL $1 $> $ HsAppInfix $2)
1838                                                [mj AnnSimpleQuote $1] }
1839         | SIMPLEQUOTE varop             {% ams (sLL $1 $> $ HsAppInfix $2)
1840                                                [mj AnnSimpleQuote $1] }
1841
1842 atype :: { LHsType RdrName }
1843         : ntgtycon                       { sL1 $1 (HsTyVar NotPromoted $1) }      -- Not including unit tuples
1844         | tyvar                          { sL1 $1 (HsTyVar NotPromoted $1) }      -- (See Note [Unit tuples])
1845         | strict_mark atype              {% ams (sLL $1 $> (HsBangTy (snd $ unLoc $1) $2))
1846                                                 (fst $ unLoc $1) }  -- Constructor sigs only
1847         | '{' fielddecls '}'             {% amms (checkRecordSyntax
1848                                                     (sLL $1 $> $ HsRecTy $2))
1849                                                         -- Constructor sigs only
1850                                                  [moc $1,mcc $3] }
1851         | '(' ')'                        {% ams (sLL $1 $> $ HsTupleTy
1852                                                     HsBoxedOrConstraintTuple [])
1853                                                 [mop $1,mcp $2] }
1854         | '(' ctype ',' comma_types1 ')' {% addAnnotation (gl $2) AnnComma
1855                                                           (gl $3) >>
1856                                             ams (sLL $1 $> $ HsTupleTy
1857                                              HsBoxedOrConstraintTuple ($2 : $4))
1858                                                 [mop $1,mcp $5] }
1859         | '(#' '#)'                   {% ams (sLL $1 $> $ HsTupleTy HsUnboxedTuple [])
1860                                              [mo $1,mc $2] }
1861         | '(#' comma_types1 '#)'      {% ams (sLL $1 $> $ HsTupleTy HsUnboxedTuple $2)
1862                                              [mo $1,mc $3] }
1863         | '(#' bar_types2 '#)'        {% ams (sLL $1 $> $ HsSumTy $2)
1864                                              [mo $1,mc $3] }
1865         | '[' ctype ']'               {% ams (sLL $1 $> $ HsListTy  $2) [mos $1,mcs $3] }
1866         | '[:' ctype ':]'             {% ams (sLL $1 $> $ HsPArrTy  $2) [mo $1,mc $3] }
1867         | '(' ctype ')'               {% ams (sLL $1 $> $ HsParTy   $2) [mop $1,mcp $3] }
1868         | '(' ctype '::' kind ')'     {% ams (sLL $1 $> $ HsKindSig $2 $4)
1869                                              [mop $1,mu AnnDcolon $3,mcp $5] }
1870         | quasiquote                  { sL1 $1 (HsSpliceTy (unLoc $1) placeHolderKind) }
1871         | '$(' exp ')'                {% ams (sLL $1 $> $ mkHsSpliceTy HasParens $2)
1872                                              [mj AnnOpenPE $1,mj AnnCloseP $3] }
1873         | TH_ID_SPLICE                {%ams (sLL $1 $> $ mkHsSpliceTy NoParens $ sL1 $1 $ HsVar $
1874                                              (sL1 $1 (mkUnqual varName (getTH_ID_SPLICE $1))))
1875                                              [mj AnnThIdSplice $1] }
1876                                       -- see Note [Promotion] for the followings
1877         | SIMPLEQUOTE qcon_nowiredlist {% ams (sLL $1 $> $ HsTyVar Promoted $2) [mj AnnSimpleQuote $1,mj AnnName $2] }
1878         | SIMPLEQUOTE  '(' ctype ',' comma_types1 ')'
1879                              {% addAnnotation (gl $3) AnnComma (gl $4) >>
1880                                 ams (sLL $1 $> $ HsExplicitTupleTy [] ($3 : $5))
1881                                     [mj AnnSimpleQuote $1,mop $2,mcp $6] }
1882         | SIMPLEQUOTE  '[' comma_types0 ']'     {% ams (sLL $1 $> $ HsExplicitListTy Promoted
1883                                                             placeHolderKind $3)
1884                                                        [mj AnnSimpleQuote $1,mos $2,mcs $4] }
1885         | SIMPLEQUOTE var                       {% ams (sLL $1 $> $ HsTyVar Promoted $2)
1886                                                        [mj AnnSimpleQuote $1,mj AnnName $2] }
1887
1888         -- Two or more [ty, ty, ty] must be a promoted list type, just as
1889         -- if you had written '[ty, ty, ty]
1890         -- (One means a list type, zero means the list type constructor,
1891         -- so you have to quote those.)
1892         | '[' ctype ',' comma_types1 ']'  {% addAnnotation (gl $2) AnnComma
1893                                                            (gl $3) >>
1894                                              ams (sLL $1 $> $ HsExplicitListTy NotPromoted
1895                                                      placeHolderKind ($2 : $4))
1896                                                  [mos $1,mcs $5] }
1897         | INTEGER              { sLL $1 $> $ HsTyLit $ HsNumTy (getINTEGERs $1)
1898                                                                (getINTEGER $1) }
1899         | STRING               { sLL $1 $> $ HsTyLit $ HsStrTy (getSTRINGs $1)
1900                                                                (getSTRING  $1) }
1901         | '_'                  { sL1 $1 $ mkAnonWildCardTy }
1902
1903 -- An inst_type is what occurs in the head of an instance decl
1904 --      e.g.  (Foo a, Gaz b) => Wibble a b
1905 -- It's kept as a single type for convenience.
1906 inst_type :: { LHsSigType RdrName }
1907         : sigtype                       { mkLHsSigType $1 }
1908
1909 deriv_types :: { [LHsSigType RdrName] }
1910         : typedoc                       { [mkLHsSigType $1] }
1911
1912         | typedoc ',' deriv_types       {% addAnnotation (gl $1) AnnComma (gl $2)
1913                                            >> return (mkLHsSigType $1 : $3) }
1914
1915 comma_types0  :: { [LHsType RdrName] }  -- Zero or more:  ty,ty,ty
1916         : comma_types1                  { $1 }
1917         | {- empty -}                   { [] }
1918
1919 comma_types1    :: { [LHsType RdrName] }  -- One or more:  ty,ty,ty
1920         : ctype                        { [$1] }
1921         | ctype  ',' comma_types1      {% addAnnotation (gl $1) AnnComma (gl $2)
1922                                           >> return ($1 : $3) }
1923
1924 bar_types2    :: { [LHsType RdrName] }  -- Two or more:  ty|ty|ty
1925         : ctype  '|' ctype             {% addAnnotation (gl $1) AnnVbar (gl $2)
1926                                           >> return [$1,$3] }
1927         | ctype  '|' bar_types2        {% addAnnotation (gl $1) AnnVbar (gl $2)
1928                                           >> return ($1 : $3) }
1929
1930 tv_bndrs :: { [LHsTyVarBndr RdrName] }
1931          : tv_bndr tv_bndrs             { $1 : $2 }
1932          | {- empty -}                  { [] }
1933
1934 tv_bndr :: { LHsTyVarBndr RdrName }
1935         : tyvar                         { sL1 $1 (UserTyVar $1) }
1936         | '(' tyvar '::' kind ')'       {% ams (sLL $1 $>  (KindedTyVar $2 $4))
1937                                                [mop $1,mu AnnDcolon $3
1938                                                ,mcp $5] }
1939
1940 fds :: { Located ([AddAnn],[Located (FunDep (Located RdrName))]) }
1941         : {- empty -}                   { noLoc ([],[]) }
1942         | '|' fds1                      { (sLL $1 $> ([mj AnnVbar $1]
1943                                                  ,reverse (unLoc $2))) }
1944
1945 fds1 :: { Located [Located (FunDep (Located RdrName))] }
1946         : fds1 ',' fd   {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2)
1947                            >> return (sLL $1 $> ($3 : unLoc $1)) }
1948         | fd            { sL1 $1 [$1] }
1949
1950 fd :: { Located (FunDep (Located RdrName)) }
1951         : varids0 '->' varids0  {% ams (L (comb3 $1 $2 $3)
1952                                        (reverse (unLoc $1), reverse (unLoc $3)))
1953                                        [mu AnnRarrow $2] }
1954
1955 varids0 :: { Located [Located RdrName] }
1956         : {- empty -}                   { noLoc [] }
1957         | varids0 tyvar                 { sLL $1 $> ($2 : unLoc $1) }
1958
1959 {-
1960 Note [Parsing ~]
1961 ~~~~~~~~~~~~~~~~
1962
1963 Due to parsing conflicts between laziness annotations in data type
1964 declarations (see strict_mark) and equality types ~'s are always
1965 parsed as laziness annotations, and turned into HsEqTy's in the
1966 correct places using RdrHsSyn.splitTilde.
1967
1968 Since strict_mark is parsed as part of atype which is part of type,
1969 typedoc and context (where HsEqTy previously appeared) it made most
1970 sense and was simplest to parse ~ as part of strict_mark and later
1971 turn them into HsEqTy's.
1972
1973 -}
1974
1975
1976 -----------------------------------------------------------------------------
1977 -- Kinds
1978
1979 kind :: { LHsKind RdrName }
1980         : ctype                  { $1 }
1981
1982 {- Note [Promotion]
1983    ~~~~~~~~~~~~~~~~
1984
1985 - Syntax of promoted qualified names
1986 We write 'Nat.Zero instead of Nat.'Zero when dealing with qualified
1987 names. Moreover ticks are only allowed in types, not in kinds, for a
1988 few reasons:
1989   1. we don't need quotes since we cannot define names in kinds
1990   2. if one day we merge types and kinds, tick would mean look in DataName
1991   3. we don't have a kind namespace anyway
1992
1993 - Name resolution
1994 When the user write Zero instead of 'Zero in types, we parse it a
1995 HsTyVar ("Zero", TcClsName) instead of HsTyVar ("Zero", DataName). We
1996 deal with this in the renamer. If a HsTyVar ("Zero", TcClsName) is not
1997 bounded in the type level, then we look for it in the term level (we
1998 change its namespace to DataName, see Note [Demotion] in OccName). And
1999 both become a HsTyVar ("Zero", DataName) after the renamer.
2000
2001 -}
2002
2003
2004 -----------------------------------------------------------------------------
2005 -- Datatype declarations
2006
2007 gadt_constrlist :: { Located ([AddAnn]
2008                           ,[LConDecl RdrName]) } -- Returned in order
2009         : 'where' '{'        gadt_constrs '}'   { L (comb2 $1 $3)
2010                                                     ([mj AnnWhere $1
2011                                                      ,moc $2
2012                                                      ,mcc $4]
2013                                                     , unLoc $3) }
2014         | 'where' vocurly    gadt_constrs close  { L (comb2 $1 $3)
2015                                                      ([mj AnnWhere $1]
2016                                                      , unLoc $3) }
2017         | {- empty -}                            { noLoc ([],[]) }
2018
2019 gadt_constrs :: { Located [LConDecl RdrName] }
2020         : gadt_constr_with_doc ';' gadt_constrs
2021                   {% addAnnotation (gl $1) AnnSemi (gl $2)
2022                      >> return (L (comb2 $1 $3) ($1 : unLoc $3)) }
2023         | gadt_constr_with_doc          { L (gl $1) [$1] }
2024         | {- empty -}                   { noLoc [] }
2025
2026 -- We allow the following forms:
2027 --      C :: Eq a => a -> T a
2028 --      C :: forall a. Eq a => !a -> T a
2029 --      D { x,y :: a } :: T a
2030 --      forall a. Eq a => D { x,y :: a } :: T a
2031
2032 gadt_constr_with_doc :: { LConDecl RdrName }
2033 gadt_constr_with_doc
2034         : maybe_docnext ';' gadt_constr
2035                 {% return $ addConDoc $3 $1 }
2036         | gadt_constr
2037                 {% return $1 }
2038
2039 gadt_constr :: { LConDecl RdrName }
2040     -- see Note [Difference in parsing GADT and data constructors]
2041     -- Returns a list because of:   C,D :: ty
2042         : con_list '::' sigtype
2043                 {% ams (sLL $1 $> (mkGadtDecl (unLoc $1) (mkLHsSigType $3)))
2044                        [mu AnnDcolon $2] }
2045
2046 {- Note [Difference in parsing GADT and data constructors]
2047 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2048 GADT constructors have simpler syntax than usual data constructors:
2049 in GADTs, types cannot occur to the left of '::', so they cannot be mixed
2050 with constructor names (see Note [Parsing data constructors is hard]).
2051
2052 Due to simplified syntax, GADT constructor names (left-hand side of '::')
2053 use simpler grammar production than usual data constructor names. As a
2054 consequence, GADT constructor names are resticted (names like '(*)' are
2055 allowed in usual data constructors, but not in GADTs).
2056 -}
2057
2058 constrs :: { Located ([AddAnn],[LConDecl RdrName]) }
2059         : maybe_docnext '=' constrs1    { L (comb2 $2 $3) ([mj AnnEqual $2]
2060                                                      ,addConDocs (unLoc $3) $1)}
2061
2062 constrs1 :: { Located [LConDecl RdrName] }
2063         : constrs1 maybe_docnext '|' maybe_docprev constr
2064             {% addAnnotation (gl $ head $ unLoc $1) AnnVbar (gl $3)
2065                >> return (sLL $1 $> (addConDoc $5 $2 : addConDocFirst (unLoc $1) $4)) }
2066         | constr                                          { sL1 $1 [$1] }
2067
2068 constr :: { LConDecl RdrName }
2069         : maybe_docnext forall context_no_ops '=>' constr_stuff maybe_docprev
2070                 {% ams (let (con,details) = unLoc $5 in
2071                   addConDoc (L (comb4 $2 $3 $4 $5) (mkConDeclH98 con
2072                                                    (snd $ unLoc $2) $3 details))
2073                             ($1 `mplus` $6))
2074                         (mu AnnDarrow $4:(fst $ unLoc $2)) }
2075         | maybe_docnext forall constr_stuff maybe_docprev
2076                 {% ams ( let (con,details) = unLoc $3 in
2077                   addConDoc (L (comb2 $2 $3) (mkConDeclH98 con
2078                                            (snd $ unLoc $2) (noLoc []) details))
2079                             ($1 `mplus` $4))
2080                        (fst $ unLoc $2) }
2081
2082 forall :: { Located ([AddAnn], Maybe [LHsTyVarBndr RdrName]) }
2083         : 'forall' tv_bndrs '.'       { sLL $1 $> ([mu AnnForall $1,mj AnnDot $3], Just $2) }
2084         | {- empty -}                 { noLoc ([], Nothing) }
2085
2086 constr_stuff :: { Located (Located RdrName, HsConDeclDetails RdrName) }
2087     -- See Note [Parsing data constructors is hard] in RdrHsSyn
2088         : btype_no_ops                         {% do { c <- splitCon $1
2089                                                      ; return $ sLL $1 $> c } }
2090         | btype_no_ops conop btype_no_ops      {% do { ty <- splitTilde $1
2091                                                      ; return $ sLL $1 $> ($2, InfixCon ty $3) } }
2092
2093 fielddecls :: { [LConDeclField RdrName] }
2094         : {- empty -}     { [] }
2095         | fielddecls1     { $1 }
2096
2097 fielddecls1 :: { [LConDeclField RdrName] }
2098         : fielddecl maybe_docnext ',' maybe_docprev fielddecls1
2099             {% addAnnotation (gl $1) AnnComma (gl $3) >>
2100                return ((addFieldDoc $1 $4) : addFieldDocs $5 $2) }
2101         | fielddecl   { [$1] }
2102
2103 fielddecl :: { LConDeclField RdrName }
2104                                               -- A list because of   f,g :: Int
2105         : maybe_docnext sig_vars '::' ctype maybe_docprev
2106             {% ams (L (comb2 $2 $4)
2107                       (ConDeclField (reverse (map (\ln@(L l n) -> L l $ FieldOcc ln PlaceHolder) (unLoc $2))) $4 ($1 `mplus` $5)))
2108                    [mu AnnDcolon $3] }
2109
2110 -- Reversed!
2111 maybe_derivings :: { HsDeriving RdrName }
2112         : {- empty -}             { noLoc [] }
2113         | derivings               { $1 }
2114
2115 -- A list of one or more deriving clauses at the end of a datatype
2116 derivings :: { HsDeriving RdrName }
2117         : derivings deriving      { sLL $1 $> $ $2 : unLoc $1 }
2118         | deriving                { sLL $1 $> [$1] }
2119
2120 -- The outer Located is just to allow the caller to
2121 -- know the rightmost extremity of the 'deriving' clause
2122 deriving :: { LHsDerivingClause RdrName }
2123         : 'deriving' deriv_strategy qtycondoc
2124               {% let { full_loc = comb2 $1 $> }
2125                  in ams (L full_loc $ HsDerivingClause $2 $ L full_loc
2126                             [mkLHsSigType $3])
2127                         [mj AnnDeriving $1] }
2128
2129         | 'deriving' deriv_strategy '(' ')'
2130               {% let { full_loc = comb2 $1 $> }
2131                  in ams (L full_loc $ HsDerivingClause $2 $ L full_loc [])
2132                         [mj AnnDeriving $1,mop $3,mcp $4] }
2133
2134         | 'deriving' deriv_strategy '(' deriv_types ')'
2135               {% let { full_loc = comb2 $1 $> }
2136                  in ams (L full_loc $ HsDerivingClause $2 $ L full_loc $4)
2137                         [mj AnnDeriving $1,mop $3,mcp $5] }
2138              -- Glasgow extension: allow partial
2139              -- applications in derivings
2140
2141 -----------------------------------------------------------------------------
2142 -- Value definitions
2143
2144 {- Note [Declaration/signature overlap]
2145 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2146 There's an awkward overlap with a type signature.  Consider
2147         f :: Int -> Int = ...rhs...
2148    Then we can't tell whether it's a type signature or a value
2149    definition with a result signature until we see the '='.
2150    So we have to inline enough to postpone reductions until we know.
2151 -}
2152
2153 {-
2154   ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var
2155   instead of qvar, we get another shift/reduce-conflict. Consider the
2156   following programs:
2157
2158      { (^^) :: Int->Int ; }          Type signature; only var allowed
2159
2160      { (^^) :: Int->Int = ... ; }    Value defn with result signature;
2161                                      qvar allowed (because of instance decls)
2162
2163   We can't tell whether to reduce var to qvar until after we've read the signatures.
2164 -}
2165
2166 docdecl :: { LHsDecl RdrName }
2167         : docdecld { sL1 $1 (DocD (unLoc $1)) }
2168
2169 docdecld :: { LDocDecl }
2170         : docnext                               { sL1 $1 (DocCommentNext (unLoc $1)) }
2171         | docprev                               { sL1 $1 (DocCommentPrev (unLoc $1)) }
2172         | docnamed                              { sL1 $1 (case (unLoc $1) of (n, doc) -> DocCommentNamed n doc) }
2173         | docsection                            { sL1 $1 (case (unLoc $1) of (n, doc) -> DocGroup n doc) }
2174
2175 decl_no_th :: { LHsDecl RdrName }
2176         : sigdecl               { $1 }
2177
2178         | '!' aexp rhs          {% do { let { e = sLL $1 $2 (SectionR (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2) };
2179                                         pat <- checkPattern empty e;
2180                                         _ <- ams (sLL $1 $> ())
2181                                                (fst $ unLoc $3);
2182                                         return $ sLL $1 $> $ ValD $
2183                                             PatBind pat (snd $ unLoc $3)
2184                                                     placeHolderType
2185                                                     placeHolderNames
2186                                                     ([],[]) } }
2187                                 -- Turn it all into an expression so that
2188                                 -- checkPattern can check that bangs are enabled
2189
2190         | infixexp_top opt_sig rhs  {% do { (ann,r) <- checkValDef empty $1 (snd $2) $3;
2191                                         let { l = comb2 $1 $> };
2192                                         case r of {
2193                                           (FunBind n _ _ _ _) ->
2194                                                 ams (L l ()) (mj AnnFunId n:(fst $2)) >> return () ;
2195                                           (PatBind (L lh _lhs) _rhs _ _ _) ->
2196                                                 ams (L lh ()) (fst $2) >> return () } ;
2197                                         _ <- ams (L l ()) (ann ++ (fst $ unLoc $3));
2198                                         return $! (sL l $ ValD r) } }
2199         | pattern_synonym_decl  { $1 }
2200         | docdecl               { $1 }
2201
2202 decl    :: { LHsDecl RdrName }
2203         : decl_no_th            { $1 }
2204
2205         -- Why do we only allow naked declaration splices in top-level
2206         -- declarations and not here? Short answer: because readFail009
2207         -- fails terribly with a panic in cvBindsAndSigs otherwise.
2208         | splice_exp            { sLL $1 $> $ mkSpliceDecl $1 }
2209
2210 rhs     :: { Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName)) }
2211         : '=' exp wherebinds    { sL (comb3 $1 $2 $3)
2212                                     ((mj AnnEqual $1 : (fst $ unLoc $3))
2213                                     ,GRHSs (unguardedRHS (comb3 $1 $2 $3) $2)
2214                                    (snd $ unLoc $3)) }
2215         | gdrhs wherebinds      { sLL $1 $>  (fst $ unLoc $2
2216                                     ,GRHSs (reverse (unLoc $1))
2217                                                     (snd $ unLoc $2)) }
2218
2219 gdrhs :: { Located [LGRHS RdrName (LHsExpr RdrName)] }
2220         : gdrhs gdrh            { sLL $1 $> ($2 : unLoc $1) }
2221         | gdrh                  { sL1 $1 [$1] }
2222
2223 gdrh :: { LGRHS RdrName (LHsExpr RdrName) }
2224         : '|' guardquals '=' exp  {% ams (sL (comb2 $1 $>) $ GRHS (unLoc $2) $4)
2225                                          [mj AnnVbar $1,mj AnnEqual $3] }
2226
2227 sigdecl :: { LHsDecl RdrName }
2228         :
2229         -- See Note [Declaration/signature overlap] for why we need infixexp here
2230           infixexp_top '::' sigtypedoc
2231                         {% do v <- checkValSigLhs $1
2232                         ; _ <- ams (sLL $1 $> ()) [mu AnnDcolon $2]
2233                         ; return (sLL $1 $> $ SigD $
2234                                   TypeSig [v] (mkLHsSigWcType $3)) }
2235
2236         | var ',' sig_vars '::' sigtypedoc
2237            {% do { let sig = TypeSig ($1 : reverse (unLoc $3))
2238                                      (mkLHsSigWcType $5)
2239                  ; addAnnotation (gl $1) AnnComma (gl $2)
2240                  ; ams ( sLL $1 $> $ SigD sig )
2241                        [mu AnnDcolon $4] } }
2242
2243         | infix prec ops
2244               {% ams (sLL $1 $> $ SigD
2245                         (FixSig (FixitySig (fromOL $ unLoc $3)
2246                                 (Fixity (fst $ unLoc $2) (snd $ unLoc $2) (unLoc $1)))))
2247                      [mj AnnInfix $1,mj AnnVal $2] }
2248
2249         | pattern_synonym_sig   { sLL $1 $> . SigD . unLoc $ $1 }
2250
2251         -- This rule is for both INLINE and INLINABLE pragmas
2252         | '{-# INLINE' activation qvar '#-}'
2253                 {% ams ((sLL $1 $> $ SigD (InlineSig $3
2254                             (mkInlinePragma (getINLINE_PRAGs $1) (getINLINE $1)
2255                                             (snd $2)))))
2256                        ((mo $1:fst $2) ++ [mc $4]) }
2257
2258         | '{-# SCC' qvar '#-}'
2259           {% ams (sLL $1 $> (SigD (SCCFunSig (getSCC_PRAGs $1) $2 Nothing)))
2260                  [mo $1, mc $3] }
2261
2262         | '{-# SCC' qvar STRING '#-}'
2263           {% do { scc <- getSCC $3
2264                 ; let str_lit = StringLiteral (getSTRINGs $3) scc
2265                 ; ams (sLL $1 $> (SigD (SCCFunSig (getSCC_PRAGs $1) $2 (Just str_lit))))
2266                       [mo $1, mc $4] } }
2267
2268         | '{-# SPECIALISE' activation qvar '::' sigtypes1 '#-}'
2269              {% ams (
2270                  let inl_prag = mkInlinePragma (getSPEC_PRAGs $1)
2271                                              (EmptyInlineSpec, FunLike) (snd $2)
2272                   in sLL $1 $> $ SigD (SpecSig $3 (fromOL $5) inl_prag))
2273                     (mo $1:mu AnnDcolon $4:mc $6:(fst $2)) }
2274
2275         | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes1 '#-}'
2276              {% ams (sLL $1 $> $ SigD (SpecSig $3 (fromOL $5)
2277                                (mkInlinePragma (getSPEC_INLINE_PRAGs $1)
2278                                                (getSPEC_INLINE $1) (snd $2))))
2279                        (mo $1:mu AnnDcolon $4:mc $6:(fst $2)) }
2280
2281         | '{-# SPECIALISE' 'instance' inst_type '#-}'
2282                 {% ams (sLL $1 $>
2283                                   $ SigD (SpecInstSig (getSPEC_PRAGs $1) $3))
2284                        [mo $1,mj AnnInstance $2,mc $4] }
2285
2286         -- A minimal complete definition
2287         | '{-# MINIMAL' name_boolformula_opt '#-}'
2288             {% ams (sLL $1 $> $ SigD (MinimalSig (getMINIMAL_PRAGs $1) $2))
2289                    [mo $1,mc $3] }
2290
2291 activation :: { ([AddAnn],Maybe Activation) }
2292         : {- empty -}                           { ([],Nothing) }
2293         | explicit_activation                   { (fst $1,Just (snd $1)) }
2294
2295 explicit_activation :: { ([AddAnn],Activation) }  -- In brackets
2296         : '[' INTEGER ']'       { ([mj AnnOpenS $1,mj AnnVal $2,mj AnnCloseS $3]
2297                                   ,ActiveAfter  (getINTEGERs $2) (fromInteger (getINTEGER $2))) }
2298         | '[' '~' INTEGER ']'   { ([mj AnnOpenS $1,mj AnnTilde $2,mj AnnVal $3
2299                                                  ,mj AnnCloseS $4]
2300                                   ,ActiveBefore (getINTEGERs $3) (fromInteger (getINTEGER $3))) }
2301
2302 -----------------------------------------------------------------------------
2303 -- Expressions
2304
2305 quasiquote :: { Located (HsSplice RdrName) }
2306         : TH_QUASIQUOTE   { let { loc = getLoc $1
2307                                 ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc $1
2308                                 ; quoterId = mkUnqual varName quoter }
2309                             in sL1 $1 (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote) }
2310         | TH_QQUASIQUOTE  { let { loc = getLoc $1
2311                                 ; ITqQuasiQuote (qual, quoter, quote, quoteSpan) = unLoc $1
2312                                 ; quoterId = mkQual varName (qual, quoter) }
2313                             in sL (getLoc $1) (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote) }
2314
2315 exp   :: { LHsExpr RdrName }
2316         : infixexp '::' sigtype {% ams (sLL $1 $> $ ExprWithTySig $1 (mkLHsSigWcType $3))
2317                                        [mu AnnDcolon $2] }
2318         | infixexp '-<' exp     {% ams (sLL $1 $> $ HsArrApp $1 $3 placeHolderType
2319                                                         HsFirstOrderApp True)
2320                                        [mu Annlarrowtail $2] }
2321         | infixexp '>-' exp     {% ams (sLL $1 $> $ HsArrApp $3 $1 placeHolderType
2322                                                       HsFirstOrderApp False)
2323                                        [mu Annrarrowtail $2] }
2324         | infixexp '-<<' exp    {% ams (sLL $1 $> $ HsArrApp $1 $3 placeHolderType
2325                                                       HsHigherOrderApp True)
2326                                        [mu AnnLarrowtail $2] }
2327         | infixexp '>>-' exp    {% ams (sLL $1 $> $ HsArrApp $3 $1 placeHolderType
2328                                                       HsHigherOrderApp False)
2329                                        [mu AnnRarrowtail $2] }
2330         | infixexp              { $1 }
2331
2332 infixexp :: { LHsExpr RdrName }
2333         : exp10 { $1 }
2334         | infixexp qop exp10  {% ams (sLL $1 $> (OpApp $1 $2 placeHolderFixity $3))
2335                                      [mj AnnVal $2] }
2336                  -- AnnVal annotation for NPlusKPat, which discards the operator
2337
2338 infixexp_top :: { LHsExpr RdrName }
2339         : exp10_top               { $1 }
2340         | infixexp_top qop exp10_top
2341                                   {% ams (sLL $1 $> (OpApp $1 $2 placeHolderFixity $3))
2342                                          [mj AnnVal $2] }
2343
2344 exp10_top :: { LHsExpr RdrName }
2345         : '\\' apat apats opt_asig '->' exp
2346                    {% ams (sLL $1 $> $ HsLam (mkMatchGroup FromSource
2347                             [sLL $1 $> $ Match { m_ctxt = LambdaExpr
2348                                                , m_pats = $2:$3
2349                                                , m_type = snd $4
2350                                                , m_grhss = unguardedGRHSs $6 }]))
2351                           (mj AnnLam $1:mu AnnRarrow $5:(fst $4)) }
2352
2353         | 'let' binds 'in' exp          {% ams (sLL $1 $> $ HsLet (snd $ unLoc $2) $4)
2354                                                (mj AnnLet $1:mj AnnIn $3
2355                                                  :(fst $ unLoc $2)) }
2356         | '\\' 'lcase' altslist
2357             {% ams (sLL $1 $> $ HsLamCase
2358                                    (mkMatchGroup FromSource (snd $ unLoc $3)))
2359                    (mj AnnLam $1:mj AnnCase $2:(fst $ unLoc $3)) }
2360         | 'if' exp optSemi 'then' exp optSemi 'else' exp
2361                            {% checkDoAndIfThenElse $2 (snd $3) $5 (snd $6) $8 >>
2362                               ams (sLL $1 $> $ mkHsIf $2 $5 $8)
2363                                   (mj AnnIf $1:mj AnnThen $4
2364                                      :mj AnnElse $7
2365                                      :(map (\l -> mj AnnSemi l) (fst $3))
2366                                     ++(map (\l -> mj AnnSemi l) (fst $6))) }
2367         | 'if' ifgdpats                 {% hintMultiWayIf (getLoc $1) >>
2368                                            ams (sLL $1 $> $ HsMultiIf
2369                                                      placeHolderType
2370                                                      (reverse $ snd $ unLoc $2))
2371                                                (mj AnnIf $1:(fst $ unLoc $2)) }
2372         | 'case' exp 'of' altslist      {% ams (sLL $1 $> $ HsCase $2 (mkMatchGroup
2373                                                    FromSource (snd $ unLoc $4)))
2374                                                (mj AnnCase $1:mj AnnOf $3
2375                                                   :(fst $ unLoc $4)) }
2376         | '-' fexp                      {% ams (sLL $1 $> $ NegApp $2 noSyntaxExpr)
2377                                                [mj AnnMinus $1] }
2378
2379         | 'do' stmtlist              {% ams (L (comb2 $1 $2)
2380                                                (mkHsDo DoExpr (snd $ unLoc $2)))
2381                                                (mj AnnDo $1:(fst $ unLoc $2)) }
2382         | 'mdo' stmtlist            {% ams (L (comb2 $1 $2)
2383                                               (mkHsDo MDoExpr (snd $ unLoc $2)))
2384                                            (mj AnnMdo $1:(fst $ unLoc $2)) }
2385
2386         | hpc_annot exp        {% ams (sLL $1 $> $ HsTickPragma (snd $ fst $ fst $ unLoc $1)
2387                                                                 (snd $ fst $ unLoc $1) (snd $ unLoc $1) $2)
2388                                       (fst $ fst $ fst $ unLoc $1) }
2389
2390         | 'proc' aexp '->' exp
2391                        {% checkPattern empty $2 >>= \ p ->
2392                            checkCommand $4 >>= \ cmd ->
2393                            ams (sLL $1 $> $ HsProc p (sLL $1 $> $ HsCmdTop cmd placeHolderType
2394                                                 placeHolderType []))
2395                                             -- TODO: is LL right here?
2396                                [mj AnnProc $1,mu AnnRarrow $3] }
2397
2398         | '{-# CORE' STRING '#-}' exp  {% ams (sLL $1 $> $ HsCoreAnn (getCORE_PRAGs $1) (getStringLiteral $2) $4)
2399                                               [mo $1,mj AnnVal $2
2400                                               ,mc $3] }
2401                                           -- hdaume: core annotation
2402         | fexp                         { $1 }
2403
2404 exp10 :: { LHsExpr RdrName }
2405         : exp10_top            { $1 }
2406         | scc_annot exp        {% ams (sLL $1 $> $ HsSCC (snd $ fst $ unLoc $1) (snd $ unLoc $1) $2)
2407                                       (fst $ fst $ unLoc $1) }
2408
2409 optSemi :: { ([Located a],Bool) }
2410         : ';'         { ([$1],True) }
2411         | {- empty -} { ([],False) }
2412
2413 scc_annot :: { Located (([AddAnn],SourceText),StringLiteral) }
2414         : '{-# SCC' STRING '#-}'      {% do scc <- getSCC $2
2415                                             ; return $ sLL $1 $>
2416                                                (([mo $1,mj AnnValStr $2
2417                                                 ,mc $3],getSCC_PRAGs $1),(StringLiteral (getSTRINGs $2) scc)) }
2418         | '{-# SCC' VARID  '#-}'      { sLL $1 $> (([mo $1,mj AnnVal $2
2419                                          ,mc $3],getSCC_PRAGs $1)
2420                                         ,(StringLiteral NoSourceText (getVARID $2))) }
2421
2422 hpc_annot :: { Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),
2423                          ((SourceText,SourceText),(SourceText,SourceText))
2424                        ) }
2425       : '{-# GENERATED' STRING INTEGER ':' INTEGER '-' INTEGER ':' INTEGER '#-}'
2426                                       { sLL $1 $> $ ((([mo $1,mj AnnVal $2
2427                                               ,mj AnnVal $3,mj AnnColon $4
2428                                               ,mj AnnVal $5,mj AnnMinus $6
2429                                               ,mj AnnVal $7,mj AnnColon $8
2430                                               ,mj AnnVal $9,mc $10],
2431                                                 getGENERATED_PRAGs $1)
2432                                               ,((getStringLiteral $2)
2433                                                ,( fromInteger $ getINTEGER $3
2434                                                 , fromInteger $ getINTEGER $5
2435                                                 )
2436                                                ,( fromInteger $ getINTEGER $7
2437                                                 , fromInteger $ getINTEGER $9
2438                                                 )
2439                                                ))
2440                                              , (( getINTEGERs $3
2441                                                 , getINTEGERs $5
2442                                                 )
2443                                                ,( getINTEGERs $7
2444                                                 , getINTEGERs $9
2445                                                 )))
2446                                          }
2447
2448 fexp    :: { LHsExpr RdrName }
2449         : fexp aexp                  { sLL $1 $> $ HsApp $1 $2 }
2450         | fexp TYPEAPP atype         {% ams (sLL $1 $> $ HsAppType $1 (mkHsWildCardBndrs $3))
2451                                             [mj AnnAt $2] }
2452         | 'static' aexp              {% ams (sLL $1 $> $ HsStatic placeHolderNames $2)
2453                                             [mj AnnStatic $1] }
2454         | aexp                       { $1 }
2455
2456 aexp    :: { LHsExpr RdrName }
2457         : qvar '@' aexp         {% ams (sLL $1 $> $ EAsPat $1 $3) [mj AnnAt $2] }
2458             -- If you change the parsing, make sure to understand
2459             -- Note [Lexing type applications] in Lexer.x
2460
2461         | '~' aexp              {% ams (sLL $1 $> $ ELazyPat $2) [mj AnnTilde $1] }
2462         | aexp1                 { $1 }
2463
2464 aexp1   :: { LHsExpr RdrName }
2465         : aexp1 '{' fbinds '}' {% do { r <- mkRecConstrOrUpdate $1 (comb2 $2 $4)
2466                                                                    (snd $3)
2467                                      ; _ <- ams (sLL $1 $> ()) (moc $2:mcc $4:(fst $3))
2468                                      ; checkRecordSyntax (sLL $1 $> r) }}
2469         | aexp2                { $1 }
2470
2471 aexp2   :: { LHsExpr RdrName }
2472         : qvar                          { sL1 $1 (HsVar   $! $1) }
2473         | qcon                          { sL1 $1 (HsVar   $! $1) }
2474         | ipvar                         { sL1 $1 (HsIPVar $! unLoc $1) }
2475         | overloaded_label              { sL1 $1 (HsOverLabel $! unLoc $1) }
2476         | literal                       { sL1 $1 (HsLit   $! unLoc $1) }
2477 -- This will enable overloaded strings permanently.  Normally the renamer turns HsString
2478 -- into HsOverLit when -foverloaded-strings is on.
2479 --      | STRING    { sL (getLoc $1) (HsOverLit $! mkHsIsString (getSTRINGs $1)
2480 --                                       (getSTRING $1) placeHolderType) }
2481         | INTEGER   { sL (getLoc $1) (HsOverLit $! mkHsIntegral (getINTEGERs $1)
2482                                          (getINTEGER $1) placeHolderType) }
2483         | RATIONAL  { sL (getLoc $1) (HsOverLit $! mkHsFractional
2484                                           (getRATIONAL $1) placeHolderType) }
2485
2486         -- N.B.: sections get parsed by these next two productions.
2487         -- This allows you to write, e.g., '(+ 3, 4 -)', which isn't
2488         -- correct Haskell (you'd have to write '((+ 3), (4 -))')
2489         -- but the less cluttered version fell out of having texps.
2490         | '(' texp ')'                  {% ams (sLL $1 $> (HsPar $2)) [mop $1,mcp $3] }
2491         | '(' tup_exprs ')'             {% do { e <- mkSumOrTuple Boxed (comb2 $1 $3) (snd $2)
2492                                               ; ams (sLL $1 $> e) ((mop $1:fst $2) ++ [mcp $3]) } }
2493
2494         | '(#' texp '#)'                {% ams (sLL $1 $> (ExplicitTuple [L (gl $2)
2495                                                          (Present $2)] Unboxed))
2496                                                [mo $1,mc $3] }
2497         | '(#' tup_exprs '#)'           {% do { e <- mkSumOrTuple Unboxed (comb2 $1 $3) (snd $2)
2498                                               ; ams (sLL $1 $> e) ((mo $1:fst $2) ++ [mc $3]) } }
2499
2500         | '[' list ']'      {% ams (sLL $1 $> (snd $2)) (mos $1:mcs $3:(fst $2)) }
2501         | '[:' parr ':]'    {% ams (sLL $1 $> (snd $2)) (mo $1:mc $3:(fst $2)) }
2502         | '_'               { sL1 $1 EWildPat }
2503
2504         -- Template Haskell Extension
2505         | splice_exp            { $1 }
2506
2507         | SIMPLEQUOTE  qvar     {% ams (sLL $1 $> $ HsBracket (VarBr True  (unLoc $2))) [mj AnnSimpleQuote $1,mj AnnName $2] }
2508         | SIMPLEQUOTE  qcon     {% ams (sLL $1 $> $ HsBracket (VarBr True  (unLoc $2))) [mj AnnSimpleQuote $1,mj AnnName $2] }
2509         | TH_TY_QUOTE tyvar     {% ams (sLL $1 $> $ HsBracket (VarBr False (unLoc $2))) [mj AnnThTyQuote $1,mj AnnName $2] }
2510         | TH_TY_QUOTE gtycon    {% ams (sLL $1 $> $ HsBracket (VarBr False (unLoc $2))) [mj AnnThTyQuote $1,mj AnnName $2] }
2511         | '[|' exp '|]'       {% ams (sLL $1 $> $ HsBracket (ExpBr $2))
2512                                       (if (hasE $1) then [mj AnnOpenE $1,mc $3] else [mo $1,mc $3]) }
2513         | '[||' exp '||]'     {% ams (sLL $1 $> $ HsBracket (TExpBr $2))
2514                                       (if (hasE $1) then [mj AnnOpenE $1,mc $3] else [mo $1,mc $3]) }
2515         | '[t|' ctype '|]'    {% ams (sLL $1 $> $ HsBracket (TypBr $2)) [mo $1,mc $3] }
2516         | '[p|' infixexp '|]' {% checkPattern empty $2 >>= \p ->
2517                                       ams (sLL $1 $> $ HsBracket (PatBr p))
2518                                           [mo $1,mc $3] }
2519         | '[d|' cvtopbody '|]' {% ams (sLL $1 $> $ HsBracket (DecBrL (snd $2)))
2520                                       (mo $1:mc $3:fst $2) }
2521         | quasiquote          { sL1 $1 (HsSpliceE (unLoc $1)) }
2522
2523         -- arrow notation extension
2524         | '(|' aexp2 cmdargs '|)'  {% ams (sLL $1 $> $ HsArrForm $2
2525                                                            Nothing (reverse $3))
2526                                           [mo $1,mc $4] }
2527
2528 splice_exp :: { LHsExpr RdrName }
2529         : TH_ID_SPLICE          {% ams (sL1 $1 $ mkHsSpliceE NoParens
2530                                         (sL1 $1 $ HsVar (sL1 $1 (mkUnqual varName
2531                                                            (getTH_ID_SPLICE $1)))))
2532                                        [mj AnnThIdSplice $1] }
2533         | '$(' exp ')'          {% ams (sLL $1 $> $ mkHsSpliceE HasParens $2)
2534                                        [mj AnnOpenPE $1,mj AnnCloseP $3] }
2535         | TH_ID_TY_SPLICE       {% ams (sL1 $1 $ mkHsSpliceTE NoParens
2536                                         (sL1 $1 $ HsVar (sL1 $1 (mkUnqual varName
2537                                                         (getTH_ID_TY_SPLICE $1)))))
2538                                        [mj AnnThIdTySplice $1] }
2539         | '$$(' exp ')'         {% ams (sLL $1 $> $ mkHsSpliceTE HasParens $2)
2540                                        [mj AnnOpenPTE $1,mj AnnCloseP $3] }
2541
2542 cmdargs :: { [LHsCmdTop RdrName] }
2543         : cmdargs acmd                  { $2 : $1 }
2544         | {- empty -}                   { [] }
2545
2546 acmd    :: { LHsCmdTop RdrName }
2547         : aexp2                 {% checkCommand $1 >>= \ cmd ->
2548                                     return (sL1 $1 $ HsCmdTop cmd
2549                                            placeHolderType placeHolderType []) }
2550
2551 cvtopbody :: { ([AddAnn],[LHsDecl RdrName]) }
2552         :  '{'            cvtopdecls0 '}'      { ([mj AnnOpenC $1
2553                                                   ,mj AnnCloseC $3],$2) }
2554         |      vocurly    cvtopdecls0 close    { ([],$2) }
2555
2556 cvtopdecls0 :: { [LHsDecl RdrName] }
2557         : topdecls_semi         { cvTopDecls $1 }
2558         | topdecls              { cvTopDecls $1 }
2559
2560 -----------------------------------------------------------------------------
2561 -- Tuple expressions
2562
2563 -- "texp" is short for tuple expressions:
2564 -- things that can appear unparenthesized as long as they're
2565 -- inside parens or delimitted by commas
2566 texp :: { LHsExpr RdrName }
2567         : exp                           { $1 }
2568
2569         -- Note [Parsing sections]
2570         -- ~~~~~~~~~~~~~~~~~~~~~~~
2571         -- We include left and right sections here, which isn't
2572         -- technically right according to the Haskell standard.
2573         -- For example (3 +, True) isn't legal.
2574         -- However, we want to parse bang patterns like
2575         --      (!x, !y)
2576         -- and it's convenient to do so here as a section
2577         -- Then when converting expr to pattern we unravel it again
2578         -- Meanwhile, the renamer checks that real sections appear
2579         -- inside parens.
2580         | infixexp qop        { sLL $1 $> $ SectionL $1 $2 }
2581         | qopm infixexp       { sLL $1 $> $ SectionR $1 $2 }
2582
2583        -- View patterns get parenthesized above
2584         | exp '->' texp   {% ams (sLL $1 $> $ EViewPat $1 $3) [mu AnnRarrow $2] }
2585
2586 -- Always at least one comma or bar.
2587 tup_exprs :: { ([AddAnn],SumOrTuple) }
2588            : texp commas_tup_tail
2589                           {% do { addAnnotation (gl $1) AnnComma (fst $2)
2590                                 ; return ([],Tuple ((sL1 $1 (Present $1)) : snd $2)) } }
2591
2592            | texp bars    { (mvbars (fst $2), Sum 1  (snd $2 + 1) $1) }
2593
2594            | commas tup_tail
2595                 {% do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (fst $1)
2596                       ; return
2597                            ([],Tuple (map (\l -> L l missingTupArg) (fst $1) ++ $2)) } }
2598
2599            | bars texp bars0
2600                 { (mvbars (fst $1) ++ mvbars (fst $3), Sum (snd $1 + 1) (snd $1 + snd $3 + 1) $2) }
2601
2602 -- Always starts with commas; always follows an expr
2603 commas_tup_tail :: { (SrcSpan,[LHsTupArg RdrName]) }
2604 commas_tup_tail : commas tup_tail
2605        {% do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (tail $ fst $1)
2606              ; return (
2607             (head $ fst $1
2608             ,(map (\l -> L l missingTupArg) (tail $ fst $1)) ++ $2)) } }
2609
2610 -- Always follows a comma
2611 tup_tail :: { [LHsTupArg RdrName] }
2612           : texp commas_tup_tail {% addAnnotation (gl $1) AnnComma (fst $2) >>
2613                                     return ((L (gl $1) (Present $1)) : snd $2) }
2614           | texp                 { [L (gl $1) (Present $1)] }
2615           | {- empty -}          { [noLoc missingTupArg] }
2616
2617 -----------------------------------------------------------------------------
2618 -- List expressions
2619
2620 -- The rules below are little bit contorted to keep lexps left-recursive while
2621 -- avoiding another shift/reduce-conflict.
2622 list :: { ([AddAnn],HsExpr RdrName) }
2623         : texp    { ([],ExplicitList placeHolderType Nothing [$1]) }
2624         | lexps   { ([],ExplicitList placeHolderType Nothing
2625                                                    (reverse (unLoc $1))) }
2626         | texp '..'             { ([mj AnnDotdot $2],
2627                                       ArithSeq noPostTcExpr Nothing (From $1)) }
2628         | texp ',' exp '..'     { ([mj AnnComma $2,mj AnnDotdot $4],
2629                                   ArithSeq noPostTcExpr Nothing
2630                                                              (FromThen $1 $3)) }
2631         | texp '..' exp         { ([mj AnnDotdot $2],
2632                                    ArithSeq noPostTcExpr Nothing
2633                                                                (FromTo $1 $3)) }
2634         | texp ',' exp '..' exp { ([mj AnnComma $2,mj AnnDotdot $4],
2635                                     ArithSeq noPostTcExpr Nothing
2636                                                 (FromThenTo $1 $3 $5)) }
2637         | texp '|' flattenedpquals
2638              {% checkMonadComp >>= \ ctxt ->
2639                 return ([mj AnnVbar $2],
2640                         mkHsComp ctxt (unLoc $3) $1) }
2641
2642 lexps :: { Located [LHsExpr RdrName] }
2643         : lexps ',' texp          {% addAnnotation (gl $ head $ unLoc $1)
2644                                                             AnnComma (gl $2) >>
2645                                       return (sLL $1 $> (((:) $! $3) $! unLoc $1)) }
2646         | texp ',' texp            {% addAnnotation (gl $1) AnnComma (gl $2) >>
2647                                       return (sLL $1 $> [$3,$1]) }
2648
2649 -----------------------------------------------------------------------------
2650 -- List Comprehensions
2651
2652 flattenedpquals :: { Located [LStmt RdrName (LHsExpr RdrName)] }
2653     : pquals   { case (unLoc $1) of
2654                     [qs] -> sL1 $1 qs
2655                     -- We just had one thing in our "parallel" list so
2656                     -- we simply return that thing directly
2657
2658                     qss -> sL1 $1 [sL1 $1 $ ParStmt [ParStmtBlock qs [] noSyntaxExpr |
2659                                             qs <- qss]
2660                                             noExpr noSyntaxExpr placeHolderType]
2661                     -- We actually found some actual parallel lists so
2662                     -- we wrap them into as a ParStmt
2663                 }
2664
2665 pquals :: { Located [[LStmt RdrName (LHsExpr RdrName)]] }
2666     : squals '|' pquals
2667                      {% addAnnotation (gl $ head $ unLoc $1) AnnVbar (gl $2) >>
2668                         return (sLL $1 $> (reverse (unLoc $1) : unLoc $3)) }
2669     | squals         { L (getLoc $1) [reverse (unLoc $1)] }
2670
2671 squals :: { Located [LStmt RdrName (LHsExpr RdrName)] }   -- In reverse order, because the last
2672                                         -- one can "grab" the earlier ones
2673     : squals ',' transformqual
2674              {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2) >>
2675                 ams (sLL $1 $> ()) (fst $ unLoc $3) >>
2676                 return (sLL $1 $> [sLL $1 $> ((snd $ unLoc $3) (reverse (unLoc $1)))]) }
2677     | squals ',' qual
2678              {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2) >>
2679                 return (sLL $1 $> ($3 : unLoc $1)) }
2680     | transformqual        {% ams $1 (fst $ unLoc $1) >>
2681                               return (sLL $1 $> [L (getLoc $1) ((snd $ unLoc $1) [])]) }
2682     | qual                                { sL1 $1 [$1] }
2683 --  | transformquals1 ',' '{|' pquals '|}'   { sLL $1 $> ($4 : unLoc $1) }
2684 --  | '{|' pquals '|}'                       { sL1 $1 [$2] }
2685
2686 -- It is possible to enable bracketing (associating) qualifier lists
2687 -- by uncommenting the lines with {| |} above. Due to a lack of
2688 -- consensus on the syntax, this feature is not being used until we
2689 -- get user demand.
2690
2691 transformqual :: { Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)] -> Stmt RdrName (LHsExpr RdrName)) }
2692                         -- Function is applied to a list of stmts *in order*
2693     : 'then' exp               { sLL $1 $> ([mj AnnThen $1], \ss -> (mkTransformStmt ss $2)) }
2694     | 'then' exp 'by' exp      { sLL $1 $> ([mj AnnThen $1,mj AnnBy  $3],\ss -> (mkTransformByStmt ss $2 $4)) }
2695     | 'then' 'group' 'using' exp
2696              { sLL $1 $> ([mj AnnThen $1,mj AnnGroup $2,mj AnnUsing $3], \ss -> (mkGroupUsingStmt ss $4)) }
2697
2698     | 'then' 'group' 'by' exp 'using' exp
2699              { sLL $1 $> ([mj AnnThen $1,mj AnnGroup $2,mj AnnBy $3,mj AnnUsing $5], \ss -> (mkGroupByUsingStmt ss $4 $6)) }
2700
2701 -- Note that 'group' is a special_id, which means that you can enable
2702 -- TransformListComp while still using Data.List.group. However, this
2703 -- introduces a shift/reduce conflict. Happy chooses to resolve the conflict
2704 -- in by choosing the "group by" variant, which is what we want.
2705
2706 -----------------------------------------------------------------------------
2707 -- Parallel array expressions
2708
2709 -- The rules below are little bit contorted; see the list case for details.
2710 -- Note that, in contrast to lists, we only have finite arithmetic sequences.
2711 -- Moreover, we allow explicit arrays with no element (represented by the nil
2712 -- constructor in the list case).
2713
2714 parr :: { ([AddAnn],HsExpr RdrName) }
2715         :                      { ([],ExplicitPArr placeHolderType []) }
2716         | texp                 { ([],ExplicitPArr placeHolderType [$1]) }
2717         | lexps                { ([],ExplicitPArr placeHolderType
2718                                                           (reverse (unLoc $1))) }
2719         | texp '..' exp        { ([mj AnnDotdot $2]
2720                                  ,PArrSeq noPostTcExpr (FromTo $1 $3)) }
2721         | texp ',' exp '..' exp
2722                         { ([mj AnnComma $2,mj AnnDotdot $4]
2723                           ,PArrSeq noPostTcExpr (FromThenTo $1 $3 $5)) }
2724         | texp '|' flattenedpquals
2725                         { ([mj AnnVbar $2],mkHsComp PArrComp (unLoc $3) $1) }
2726
2727 -- We are reusing `lexps' and `flattenedpquals' from the list case.
2728
2729 -----------------------------------------------------------------------------
2730 -- Guards
2731
2732 guardquals :: { Located [LStmt RdrName (LHsExpr RdrName)] }
2733     : guardquals1           { L (getLoc $1) (reverse (unLoc $1)) }
2734
2735 guardquals1 :: { Located [LStmt RdrName (LHsExpr RdrName)] }
2736     : guardquals1 ',' qual  {% addAnnotation (gl $ head $ unLoc $1) AnnComma
2737                                              (gl $2) >>
2738                                return (sLL $1 $> ($3 : unLoc $1)) }
2739     | qual                  { sL1 $1 [$1] }
2740
2741 -----------------------------------------------------------------------------
2742 -- Case alternatives
2743
2744 altslist :: { Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]) }
2745         : '{'            alts '}'  { sLL $1 $> ((moc $1:mcc $3:(fst $ unLoc $2))
2746                                                ,(reverse (snd $ unLoc $2))) }
2747         |     vocurly    alts  close { L (getLoc $2) (fst $ unLoc $2
2748                                         ,(reverse (snd $ unLoc $2))) }
2749         | '{'                 '}'    { noLoc ([moc $1,mcc $2],[]) }
2750         |     vocurly          close { noLoc ([],[]) }
2751
2752 alts    :: { Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]) }
2753         : alts1                    { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }
2754         | ';' alts                 { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2))
2755                                                ,snd $ unLoc $2) }
2756
2757 alts1   :: { Located ([AddAnn],[LMatch RdrName (LHsExpr RdrName)]) }
2758         : alts1 ';' alt         {% if null (snd $ unLoc $1)
2759                                      then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
2760                                                   ,[$3]))
2761                                      else (ams (head $ snd $ unLoc $1)
2762                                                (mj AnnSemi $2:(fst $ unLoc $1))
2763                                            >> return (sLL $1 $> ([],$3 : (snd $ unLoc $1))) ) }
2764         | alts1 ';'             {% if null (snd $ unLoc $1)
2765                                      then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
2766                                                   ,snd $ unLoc $1))
2767                                      else (ams (head $ snd $ unLoc $1)
2768                                                (mj AnnSemi $2:(fst $ unLoc $1))
2769                                            >> return (sLL $1 $> ([],snd $ unLoc $1))) }
2770         | alt                   { sL1 $1 ([],[$1]) }
2771
2772 alt     :: { LMatch RdrName (LHsExpr RdrName) }
2773         : pat opt_asig alt_rhs  {%ams (sLL $1 $> (Match { m_ctxt = CaseAlt
2774                                                         , m_pats = [$1]
2775                                                         , m_type = snd $2
2776                                                         , m_grhss = snd $ unLoc $3 }))
2777                                       (fst $2 ++ (fst $ unLoc $3))}
2778
2779 alt_rhs :: { Located ([AddAnn],GRHSs RdrName (LHsExpr RdrName)) }
2780         : ralt wherebinds           { sLL $1 $> (fst $ unLoc $2,
2781                                             GRHSs (unLoc $1) (snd $ unLoc $2)) }
2782
2783 ralt :: { Located [LGRHS RdrName (LHsExpr RdrName)] }
2784         : '->' exp            {% ams (sLL $1 $> (unguardedRHS (comb2 $1 $2) $2))
2785                                      [mu AnnRarrow $1] }
2786         | gdpats              { sL1 $1 (reverse (unLoc $1)) }
2787
2788 gdpats :: { Located [LGRHS RdrName (LHsExpr RdrName)] }
2789         : gdpats gdpat                  { sLL $1 $> ($2 : unLoc $1) }
2790         | gdpat                         { sL1 $1 [$1] }
2791
2792 -- layout for MultiWayIf doesn't begin with an open brace, because it's hard to
2793 -- generate the open brace in addition to the vertical bar in the lexer, and
2794 -- we don't need it.
2795 ifgdpats :: { Located ([AddAnn],[LGRHS RdrName (LHsExpr RdrName)]) }
2796          : '{' gdpats '}'                 { sLL $1 $> ([moc $1,mcc $3],unLoc $2)  }
2797          |     gdpats close               { sL1 $1 ([],unLoc $1) }
2798
2799 gdpat   :: { LGRHS RdrName (LHsExpr RdrName) }
2800         : '|' guardquals '->' exp
2801                                   {% ams (sL (comb2 $1 $>) $ GRHS (unLoc $2) $4)
2802                                          [mj AnnVbar $1,mu AnnRarrow $3] }
2803
2804 -- 'pat' recognises a pattern, including one with a bang at the top
2805 --      e.g.  "!x" or "!(x,y)" or "C a b" etc
2806 -- Bangs inside are parsed as infix operator applications, so that
2807 -- we parse them right when bang-patterns are off
2808 pat     :: { LPat RdrName }
2809 pat     :  exp          {% checkPattern empty $1 }
2810         | '!' aexp      {% amms (checkPattern empty (sLL $1 $> (SectionR
2811                                                      (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2)))
2812                                 [mj AnnBang $1] }
2813
2814 bindpat :: { LPat RdrName }
2815 bindpat :  exp            {% checkPattern
2816                                 (text "Possibly caused by a missing 'do'?") $1 }
2817         | '!' aexp        {% amms (checkPattern
2818                                      (text "Possibly caused by a missing 'do'?")
2819                                      (sLL $1 $> (SectionR (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2)))
2820                                   [mj AnnBang $1] }
2821
2822 apat   :: { LPat RdrName }
2823 apat    : aexp                  {% checkPattern empty $1 }
2824         | '!' aexp              {% amms (checkPattern empty
2825                                             (sLL $1 $> (SectionR
2826                                                 (sL1 $1 (HsVar (sL1 $1 bang_RDR))) $2)))
2827                                         [mj AnnBang $1] }
2828
2829 apats  :: { [LPat RdrName] }
2830         : apat apats            { $1 : $2 }
2831         | {- empty -}           { [] }
2832
2833 -----------------------------------------------------------------------------
2834 -- Statement sequences
2835
2836 stmtlist :: { Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)]) }
2837         : '{'           stmts '}'       { sLL $1 $> ((moc $1:mcc $3:(fst $ unLoc $2))
2838                                              ,(reverse $ snd $ unLoc $2)) } -- AZ:performance of reverse?
2839         |     vocurly   stmts close     { L (gl $2) (fst $ unLoc $2
2840                                                     ,reverse $ snd $ unLoc $2) }
2841
2842 --      do { ;; s ; s ; ; s ;; }
2843 -- The last Stmt should be an expression, but that's hard to enforce
2844 -- here, because we need too much lookahead if we see do { e ; }
2845 -- So we use BodyStmts throughout, and switch the last one over
2846 -- in ParseUtils.checkDo instead
2847
2848 stmts :: { Located ([AddAnn],[LStmt RdrName (LHsExpr RdrName)]) }
2849         : stmts ';' stmt  {% if null (snd $ unLoc $1)
2850                               then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
2851                                                      ,$3 : (snd $ unLoc $1)))
2852                               else do
2853                                { ams (head $ snd $ unLoc $1) [mj AnnSemi $2]
2854                                ; return $ sLL $1 $> (fst $ unLoc $1,$3 :(snd $ unLoc $1)) }}
2855
2856         | stmts ';'     {% if null (snd $ unLoc $1)
2857                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1),snd $ unLoc $1))
2858                              else do
2859                                { ams (head $ snd $ unLoc $1)
2860                                                [mj AnnSemi $2]
2861                                ; return $1 } }
2862         | stmt                   { sL1 $1 ([],[$1]) }
2863         | {- empty -}            { noLoc ([],[]) }
2864
2865
2866 -- For typing stmts at the GHCi prompt, where
2867 -- the input may consist of just comments.
2868 maybe_stmt :: { Maybe (LStmt RdrName (LHsExpr RdrName)) }
2869         : stmt                          { Just $1 }
2870         | {- nothing -}                 { Nothing }
2871
2872 stmt  :: { LStmt RdrName (LHsExpr RdrName) }
2873         : qual                          { $1 }
2874         | 'rec' stmtlist                {% ams (sLL $1 $> $ mkRecStmt (snd $ unLoc $2))
2875                                                (mj AnnRec $1:(fst $ unLoc $2)) }
2876
2877 qual  :: { LStmt RdrName (LHsExpr RdrName) }
2878     : bindpat '<-' exp                  {% ams (sLL $1 $> $ mkBindStmt $1 $3)
2879                                                [mu AnnLarrow $2] }
2880     | exp                               { sL1 $1 $ mkBodyStmt $1 }
2881     | 'let' binds                       {% ams (sLL $1 $>$ LetStmt (snd $ unLoc $2))
2882                                                (mj AnnLet $1:(fst $ unLoc $2)) }
2883
2884 -----------------------------------------------------------------------------
2885 -- Record Field Update/Construction
2886
2887 fbinds  :: { ([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool)) }
2888         : fbinds1                       { $1 }
2889         | {- empty -}                   { ([],([], False)) }
2890
2891 fbinds1 :: { ([AddAnn],([LHsRecField RdrName (LHsExpr RdrName)], Bool)) }
2892         : fbind ',' fbinds1
2893                 {% addAnnotation (gl $1) AnnComma (gl $2) >>
2894                    return (case $3 of (ma,(flds, dd)) -> (ma,($1 : flds, dd))) }
2895         | fbind                         { ([],([$1], False)) }
2896         | '..'                          { ([mj AnnDotdot $1],([],   True)) }
2897
2898 fbind   :: { LHsRecField RdrName (LHsExpr RdrName) }
2899         : qvar '=' texp {% ams  (sLL $1 $> $ HsRecField (sL1 $1 $ mkFieldOcc $1) $3 False)
2900                                 [mj AnnEqual $2] }
2901                         -- RHS is a 'texp', allowing view patterns (Trac #6038)
2902                         -- and, incidentally, sections.  Eg
2903                         -- f (R { x = show -> s }) = ...
2904
2905         | qvar          { sLL $1 $> $ HsRecField (sL1 $1 $ mkFieldOcc $1) placeHolderPunRhs True }
2906                         -- In the punning case, use a place-holder
2907                         -- The renamer fills in the final value
2908
2909 -----------------------------------------------------------------------------
2910 -- Implicit Parameter Bindings
2911
2912 dbinds  :: { Located [LIPBind RdrName] }
2913         : dbinds ';' dbind
2914                       {% addAnnotation (gl $ last $ unLoc $1) AnnSemi (gl $2) >>
2915                          return (let { this = $3; rest = unLoc $1 }
2916                               in rest `seq` this `seq` sLL $1 $> (this : rest)) }
2917         | dbinds ';'  {% addAnnotation (gl $ last $ unLoc $1) AnnSemi (gl $2) >>
2918                          return (sLL $1 $> (unLoc $1)) }
2919         | dbind                        { let this = $1 in this `seq` sL1 $1 [this] }
2920 --      | {- empty -}                  { [] }
2921
2922 dbind   :: { LIPBind RdrName }
2923 dbind   : ipvar '=' exp                {% ams (sLL $1 $> (IPBind (Left $1) $3))
2924                                               [mj AnnEqual $2] }
2925
2926 ipvar   :: { Located HsIPName }
2927         : IPDUPVARID            { sL1 $1 (HsIPName (getIPDUPVARID $1)) }
2928
2929 -----------------------------------------------------------------------------
2930 -- Overloaded labels
2931
2932 overloaded_label :: { Located FastString }
2933         : LABELVARID          { sL1 $1 (getLABELVARID $1) }
2934
2935 -----------------------------------------------------------------------------
2936 -- Warnings and deprecations
2937
2938 name_boolformula_opt :: { LBooleanFormula (Located RdrName) }
2939         : name_boolformula          { $1 }
2940         | {- empty -}               { noLoc mkTrue }
2941
2942 name_boolformula :: { LBooleanFormula (Located RdrName) }
2943         : name_boolformula_and                      { $1 }
2944         | name_boolformula_and '|' name_boolformula
2945                            {% aa $1 (AnnVbar, $2)
2946                               >> return (sLL $1 $> (Or [$1,$3])) }
2947
2948 name_boolformula_and :: { LBooleanFormula (Located RdrName) }
2949         : name_boolformula_atom                             { $1 }
2950         | name_boolformula_atom ',' name_boolformula_and
2951                   {% aa $1 (AnnComma,$2) >> return (sLL $1 $> (And [$1,$3])) }
2952
2953 name_boolformula_atom :: { LBooleanFormula (Located RdrName) }
2954         : '(' name_boolformula ')'  {% ams (sLL $1 $> (Parens $2)) [mop $1,mcp $3] }
2955         | name_var                  { sL1 $1 (Var $1) }
2956
2957 namelist :: { Located [Located RdrName] }
2958 namelist : name_var              { sL1 $1 [$1] }
2959          | name_var ',' namelist {% addAnnotation (gl $1) AnnComma (gl $2) >>
2960                                     return (sLL $1 $> ($1 : unLoc $3)) }
2961
2962 name_var :: { Located RdrName }
2963 name_var : var { $1 }
2964          | con { $1 }
2965
2966 -----------------------------------------
2967 -- Data constructors
2968 -- There are two different productions here as lifted list constructors
2969 -- are parsed differently.
2970
2971 qcon_nowiredlist :: { Located RdrName }
2972         : gen_qcon                     { $1 }
2973         | sysdcon_nolist               { sL1 $1 $ nameRdrName (dataConName (unLoc $1)) }
2974
2975 qcon :: { Located RdrName }
2976   : gen_qcon              { $1}
2977   | sysdcon               { sL1 $1 $ nameRdrName (dataConName (unLoc $1)) }
2978
2979 gen_qcon :: { Located RdrName }
2980   : qconid                { $1 }
2981   | '(' qconsym ')'       {% ams (sLL $1 $> (unLoc $2))
2982                                    [mop $1,mj AnnVal $2,mcp $3] }
2983
2984 -- The case of '[:' ':]' is part of the production `parr'
2985
2986 con     :: { Located RdrName }
2987         : conid                 { $1 }
2988         | '(' consym ')'        {% ams (sLL $1 $> (unLoc $2))
2989                                        [mop $1,mj AnnVal $2,mcp $3] }
2990         | sysdcon               { sL1 $1 $ nameRdrName (dataConName (unLoc $1)) }
2991
2992 con_list :: { Located [Located RdrName] }
2993 con_list : con                  { sL1 $1 [$1] }
2994          | con ',' con_list     {% addAnnotation (gl $1) AnnComma (gl $2) >>
2995                                    return (sLL $1 $> ($1 : unLoc $3)) }
2996
2997 sysdcon_nolist :: { Located DataCon }  -- Wired in data constructors
2998         : '(' ')'               {% ams (sLL $1 $> unitDataCon) [mop $1,mcp $2] }
2999         | '(' commas ')'        {% ams (sLL $1 $> $ tupleDataCon Boxed (snd $2 + 1))
3000                                        (mop $1:mcp $3:(mcommas (fst $2))) }
3001         | '(#' '#)'             {% ams (sLL $1 $> $ unboxedUnitDataCon) [mo $1,mc $2] }
3002         | '(#' commas '#)'      {% ams (sLL $1 $> $ tupleDataCon Unboxed (snd $2 + 1))
3003                                        (mo $1:mc $3:(mcommas (fst $2))) }
3004
3005 sysdcon :: { Located DataCon }
3006         : sysdcon_nolist                 { $1 }
3007         | '[' ']'               {% ams (sLL $1 $> nilDataCon) [mos $1,mcs $2] }
3008
3009 conop :: { Located RdrName }
3010         : consym                { $1 }
3011         | '`' conid '`'         {% ams (sLL $1 $> (unLoc $2))
3012                                        [mj AnnBackquote $1,mj AnnVal $2
3013                                        ,mj AnnBackquote $3] }
3014
3015 qconop :: { Located RdrName }
3016         : qconsym               { $1 }
3017         | '`' qconid '`'        {% ams (sLL $1 $> (unLoc $2))
3018                                        [mj AnnBackquote $1,mj AnnVal $2
3019                                        ,mj AnnBackquote $3] }
3020
3021 ----------------------------------------------------------------------------
3022 -- Type constructors
3023
3024
3025 -- See Note [Unit tuples] in HsTypes for the distinction
3026 -- between gtycon and ntgtycon
3027 gtycon :: { Located RdrName }  -- A "general" qualified tycon, including unit tuples
3028         : ntgtycon                     { $1 }
3029         | '(' ')'                      {% ams (sLL $1 $> $ getRdrName unitTyCon)
3030                                               [mop $1,mcp $2] }
3031         | '(#' '#)'                    {% ams (sLL $1 $> $ getRdrName unboxedUnitTyCon)
3032                                               [mo $1,mc $2] }
3033
3034 ntgtycon :: { Located RdrName }  -- A "general" qualified tycon, excluding unit tuples
3035         : oqtycon               { $1 }
3036         | '(' commas ')'        {% ams (sLL $1 $> $ getRdrName (tupleTyCon Boxed
3037                                                         (snd $2 + 1)))
3038                                        (mop $1:mcp $3:(mcommas (fst $2))) }
3039         | '(#' commas '#)'      {% ams (sLL $1 $> $ getRdrName (tupleTyCon Unboxed
3040                                                         (snd $2 + 1)))
3041                                        (mo $1:mc $3:(mcommas (fst $2))) }
3042         | '(' '->' ')'          {% ams (sLL $1 $> $ getRdrName funTyCon)
3043                                        [mop $1,mu AnnRarrow $2,mcp $3] }
3044         | '[' ']'               {% ams (sLL $1 $> $ listTyCon_RDR) [mos $1,mcs $2] }
3045         | '[:' ':]'             {% ams (sLL $1 $> $ parrTyCon_RDR) [mo $1,mc $2] }
3046         | '(' '~#' ')'          {% ams (sLL $1 $> $ getRdrName eqPrimTyCon)
3047                                         [mop $1,mj AnnTildehsh $2,mcp $3] }
3048
3049 oqtycon :: { Located RdrName }  -- An "ordinary" qualified tycon;
3050                                 -- These can appear in export lists
3051         : qtycon                        { $1 }
3052         | '(' qtyconsym ')'             {% ams (sLL $1 $> (unLoc $2))
3053                                                [mop $1,mj AnnVal $2,mcp $3] }
3054         | '(' '~' ')'                   {% ams (sLL $1 $> $ eqTyCon_RDR)
3055                                                [mop $1,mj AnnVal $2,mcp $3] }
3056
3057 oqtycon_no_varcon :: { Located RdrName }  -- Type constructor which cannot be mistaken
3058                                           -- for variable constructor in export lists
3059                                           -- see Note [Type constructors in export list]
3060         :  qtycon            { $1 }
3061         | '(' QCONSYM ')'    {% let name = sL1 $2 $! mkQual tcClsName (getQCONSYM $2)
3062                                 in ams (sLL $1 $> (unLoc name)) [mop $1,mj AnnVal name,mcp $3] }
3063         | '(' CONSYM ')'     {% let name = sL1 $2 $! mkUnqual tcClsName (getCONSYM $2)
3064                                 in ams (sLL $1 $> (unLoc name)) [mop $1,mj AnnVal name,mcp $3] }
3065         | '(' ':' ')'        {% let name = sL1 $2 $! consDataCon_RDR
3066                                 in ams (sLL $1 $> (unLoc name)) [mop $1,mj AnnVal name,mcp $3] }
3067         | '(' '~' ')'        {% ams (sLL $1 $> $ eqTyCon_RDR) [mop $1,mj AnnTilde $2,mcp $3] }
3068
3069 {- Note [Type constructors in export list]
3070 ~~~~~~~~~~~~~~~~~~~~~
3071 Mixing type constructors and data constructors in export lists introduces
3072 ambiguity in grammar: e.g. (*) may be both a type constructor and a function.
3073
3074 -XExplicitNamespaces allows to disambiguate by explicitly prefixing type
3075 constructors with 'type' keyword.
3076
3077 This ambiguity causes reduce/reduce conflicts in parser, which are always
3078 resolved in favour of data constructors. To get rid of conflicts we demand
3079 that ambiguous type constructors (those, which are formed by the same
3080 productions as variable constructors) are always prefixed with 'type' keyword.
3081 Unambiguous type constructors may occur both with or without 'type' keyword.
3082
3083 Note that in the parser we still parse data constructors as type
3084 constructors. As such, they still end up in the type constructor namespace
3085 until after renaming when we resolve the proper namespace for each exported
3086 child.
3087 -}
3088
3089 qtyconop :: { Located RdrName } -- Qualified or unqualified
3090         : qtyconsym                     { $1 }
3091         | '`' qtycon '`'                {% ams (sLL $1 $> (unLoc $2))
3092                                                [mj AnnBackquote $1,mj AnnVal $2
3093                                                ,mj AnnBackquote $3] }
3094
3095 qtycon :: { Located RdrName }   -- Qualified or unqualified
3096         : QCONID            { sL1 $1 $! mkQual tcClsName (getQCONID $1) }
3097         | tycon             { $1 }
3098
3099 qtycondoc :: { LHsType RdrName } -- Qualified or unqualified
3100         : qtycon            { sL1 $1                     (HsTyVar NotPromoted $1)      }
3101         | qtycon docprev    { sLL $1 $> (HsDocTy (sL1 $1 (HsTyVar NotPromoted $1)) $2) }
3102
3103 tycon   :: { Located RdrName }  -- Unqualified
3104         : CONID                   { sL1 $1 $! mkUnqual tcClsName (getCONID $1) }
3105
3106 qtyconsym :: { Located RdrName }
3107         : QCONSYM            { sL1 $1 $! mkQual tcClsName (getQCONSYM $1) }
3108         | QVARSYM            { sL1 $1 $! mkQual tcClsName (getQVARSYM $1) }
3109         | tyconsym           { $1 }
3110
3111 -- Does not include "!", because that is used for strictness marks
3112 --               or ".", because that separates the quantified type vars from the rest
3113 tyconsym :: { Located RdrName }
3114         : CONSYM                { sL1 $1 $! mkUnqual tcClsName (getCONSYM $1) }
3115         | VARSYM                { sL1 $1 $! mkUnqual tcClsName (getVARSYM $1) }
3116         | ':'                   { sL1 $1 $! consDataCon_RDR }
3117         | '-'                   { sL1 $1 $! mkUnqual tcClsName (fsLit "-") }
3118
3119
3120 -----------------------------------------------------------------------------
3121 -- Operators
3122
3123 op      :: { Located RdrName }   -- used in infix decls
3124         : varop                 { $1 }
3125         | conop                 { $1 }
3126
3127 varop   :: { Located RdrName }
3128         : varsym                { $1 }
3129         | '`' varid '`'         {% ams (sLL $1 $> (unLoc $2))
3130                                        [mj AnnBackquote $1,mj AnnVal $2
3131                                        ,mj AnnBackquote $3] }
3132
3133 qop     :: { LHsExpr RdrName }   -- used in sections
3134         : qvarop                { sL1 $1 $ HsVar $1 }
3135         | qconop                { sL1 $1 $ HsVar $1 }
3136         | '`' '_' '`'           {% ams (sLL $1 $> EWildPat)
3137                                        [mj AnnBackquote $1,mj AnnVal $2
3138                                        ,mj AnnBackquote $3] }
3139
3140 qopm    :: { LHsExpr RdrName }   -- used in sections
3141         : qvaropm               { sL1 $1 $ HsVar $1 }
3142         | qconop                { sL1 $1 $ HsVar $1 }
3143
3144 qvarop :: { Located RdrName }
3145         : qvarsym               { $1 }
3146         | '`' qvarid '`'        {% ams (sLL $1 $> (unLoc $2))
3147                                        [mj AnnBackquote $1,mj AnnVal $2
3148                                        ,mj AnnBackquote $3] }
3149
3150 qvaropm :: { Located RdrName }
3151         : qvarsym_no_minus      { $1 }
3152         | '`' qvarid '`'        {% ams (sLL $1 $> (unLoc $2))
3153                                        [mj AnnBackquote $1,mj AnnVal $2
3154                                        ,mj AnnBackquote $3] }
3155
3156 -----------------------------------------------------------------------------
3157 -- Type variables
3158
3159 tyvar   :: { Located RdrName }
3160 tyvar   : tyvarid               { $1 }
3161
3162 tyvarop :: { Located RdrName }
3163 tyvarop : '`' tyvarid '`'       {% ams (sLL $1 $> (unLoc $2))
3164                                        [mj AnnBackquote $1,mj AnnVal $2
3165                                        ,mj AnnBackquote $3] }
3166         | '.'                   {% parseErrorSDoc (getLoc $1)
3167                                       (vcat [text "Illegal symbol '.' in type",
3168                                              text "Perhaps you intended to use RankNTypes or a similar language",
3169                                              text "extension to enable explicit-forall syntax: forall <tvs>. <type>"])
3170                                 }
3171
3172 tyvarid :: { Located RdrName }
3173         : VARID            { sL1 $1 $! mkUnqual tvName (getVARID $1) }
3174         | special_id       { sL1 $1 $! mkUnqual tvName (unLoc $1) }
3175         | 'unsafe'         { sL1 $1 $! mkUnqual tvName (fsLit "unsafe") }
3176         | 'safe'           { sL1 $1 $! mkUnqual tvName (fsLit "safe") }
3177         | 'interruptible'  { sL1 $1 $! mkUnqual tvName (fsLit "interruptible") }
3178
3179 -----------------------------------------------------------------------------
3180 -- Variables
3181
3182 var     :: { Located RdrName }
3183         : varid                 { $1 }
3184         | '(' varsym ')'        {% ams (sLL $1 $> (unLoc $2))
3185                                        [mop $1,mj AnnVal $2,mcp $3] }
3186
3187  -- Lexing type applications depends subtly on what characters can possibly
3188  -- end a qvar. Currently (June 2015), only $idchars and ")" can end a qvar.
3189  -- If you're changing this, please see Note [Lexing type applications] in
3190  -- Lexer.x.
3191 qvar    :: { Located RdrName }
3192         : qvarid                { $1 }
3193         | '(' varsym ')'        {% ams (sLL $1 $> (unLoc $2))
3194                                        [mop $1,mj AnnVal $2,mcp $3] }
3195         | '(' qvarsym1 ')'      {% ams (sLL $1 $> (unLoc $2))
3196                                        [mop $1,mj AnnVal $2,mcp $3] }
3197 -- We've inlined qvarsym here so that the decision about
3198 -- whether it's a qvar or a var can be postponed until
3199 -- *after* we see the close paren.
3200
3201 qvarid :: { Located RdrName }
3202         : varid               { $1 }
3203         | QVARID              { sL1 $1 $! mkQual varName (getQVARID $1) }
3204
3205 -- Note that 'role' and 'family' get lexed separately regardless of
3206 -- the use of extensions. However, because they are listed here,
3207 -- this is OK and they can be used as normal varids.
3208 -- See Note [Lexing type pseudo-keywords] in Lexer.x
3209 varid :: { Located RdrName }
3210         : VARID            { sL1 $1 $! mkUnqual varName (getVARID $1) }
3211         | special_id       { sL1 $1 $! mkUnqual varName (unLoc $1) }
3212         | 'unsafe'         { sL1 $1 $! mkUnqual varName (fsLit "unsafe") }
3213         | 'safe'           { sL1 $1 $! mkUnqual varName (fsLit "safe") }
3214         | 'interruptible'  { sL1 $1 $! mkUnqual varName (fsLit "interruptible")}
3215         | 'forall'         { sL1 $1 $! mkUnqual varName (fsLit "forall") }
3216         | 'family'         { sL1 $1 $! mkUnqual varName (fsLit "family") }
3217         | 'role'           { sL1 $1 $! mkUnqual varName (fsLit "role") }
3218
3219 qvarsym :: { Located RdrName }
3220         : varsym                { $1 }
3221         | qvarsym1              { $1 }
3222
3223 qvarsym_no_minus :: { Located RdrName }
3224         : varsym_no_minus       { $1 }
3225         | qvarsym1              { $1 }
3226
3227 qvarsym1 :: { Located RdrName }
3228 qvarsym1 : QVARSYM              { sL1 $1 $ mkQual varName (getQVARSYM $1) }
3229
3230 varsym :: { Located RdrName }
3231         : varsym_no_minus       { $1 }
3232         | '-'                   { sL1 $1 $ mkUnqual varName (fsLit "-") }
3233
3234 varsym_no_minus :: { Located RdrName } -- varsym not including '-'
3235         : VARSYM               { sL1 $1 $ mkUnqual varName (getVARSYM $1) }
3236         | special_sym          { sL1 $1 $ mkUnqual varName (unLoc $1) }
3237
3238
3239 -- These special_ids are treated as keywords in various places,
3240 -- but as ordinary ids elsewhere.   'special_id' collects all these
3241 -- except 'unsafe', 'interruptible', 'forall', 'family', 'role', 'stock', and
3242 -- 'anyclass', whose treatment differs depending on context
3243 special_id :: { Located FastString }
3244 special_id
3245         : 'as'                  { sL1 $1 (fsLit "as") }
3246         | 'qualified'           { sL1 $1 (fsLit "qualified") }
3247         | 'hiding'              { sL1 $1 (fsLit "hiding") }
3248         | 'export'              { sL1 $1 (fsLit "export") }
3249         | 'label'               { sL1 $1 (fsLit "label")  }
3250         | 'dynamic'             { sL1 $1 (fsLit "dynamic") }
3251         | 'stdcall'             { sL1 $1 (fsLit "stdcall") }
3252         | 'ccall'               { sL1 $1 (fsLit "ccall") }
3253         | 'capi'                { sL1 $1 (fsLit "capi") }
3254         | 'prim'                { sL1 $1 (fsLit "prim") }
3255         | 'javascript'          { sL1 $1 (fsLit "javascript") }
3256         | 'group'               { sL1 $1 (fsLit "group") }
3257         | 'stock'               { sL1 $1 (fsLit "stock") }
3258         | 'anyclass'            { sL1 $1 (fsLit "anyclass") }
3259         | 'unit'                { sL1 $1 (fsLit "unit") }
3260         | 'dependency'          { sL1 $1 (fsLit "dependency") }
3261         | 'signature'           { sL1 $1 (fsLit "signature") }
3262
3263 special_sym :: { Located FastString }
3264 special_sym : '!'       {% ams (sL1 $1 (fsLit "!")) [mj AnnBang $1] }
3265             | '.'       { sL1 $1 (fsLit ".") }
3266
3267 -----------------------------------------------------------------------------
3268 -- Data constructors
3269
3270 qconid :: { Located RdrName }   -- Qualified or unqualified
3271         : conid              { $1 }
3272         | QCONID             { sL1 $1 $! mkQual dataName (getQCONID $1) }
3273
3274 conid   :: { Located RdrName }
3275         : CONID                { sL1 $1 $ mkUnqual dataName (getCONID $1) }
3276
3277 qconsym :: { Located RdrName }  -- Qualified or unqualified
3278         : consym               { $1 }
3279         | QCONSYM              { sL1 $1 $ mkQual dataName (getQCONSYM $1) }