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