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