25edb3e5914ce7523e8f044b44d0847ce2d0697c
[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 233 -- 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 143 contains 14 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 148 contains 68 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 28 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 308 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 318 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 362 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 418 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 362 for unboxed tuples.
276
277 -------------------------------------------------------------------------------
278
279 state 429 contains 68 shift/reduce conflicts.
280
281     *** exp10 -> '-' fexp .
282         fexp -> fexp . aexp
283         fexp -> fexp . TYPEAPP atype
284
285 Same as 148 but with a unary minus.
286
287 -------------------------------------------------------------------------------
288
289 state 493 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 694 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 771 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 1019 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 1404 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 _ (ITlarrowtail _) }            -- for arrow notation
530  '>-'           { L _ (ITrarrowtail _) }            -- for arrow notation
531  '-<<'          { L _ (ITLarrowtail _) }            -- for arrow notation
532  '>>-'          { L _ (ITRarrowtail _) }            -- for arrow notation
533  '.'            { L _ ITdot }
534  TYPEAPP        { L _ ITtypeApp }
535
536  '{'            { L _ ITocurly }                        -- special symbols
537  '}'            { L _ ITccurly }
538  vocurly        { L _ ITvocurly } -- virtual open curly (from layout)
539  vccurly        { L _ ITvccurly } -- virtual close curly (from layout)
540  '['            { L _ ITobrack }
541  ']'            { L _ ITcbrack }
542  '[:'           { L _ ITopabrack }
543  ':]'           { L _ ITcpabrack }
544  '('            { L _ IToparen }
545  ')'            { L _ ITcparen }
546  '(#'           { L _ IToubxparen }
547  '#)'           { L _ ITcubxparen }
548  '(|'           { L _ (IToparenbar _) }
549  '|)'           { L _ (ITcparenbar _) }
550  ';'            { L _ ITsemi }
551  ','            { L _ ITcomma }
552  '`'            { L _ ITbackquote }
553  SIMPLEQUOTE    { L _ ITsimpleQuote      }     -- 'x
554
555  VARID          { L _ (ITvarid    _) }          -- identifiers
556  CONID          { L _ (ITconid    _) }
557  VARSYM         { L _ (ITvarsym   _) }
558  CONSYM         { L _ (ITconsym   _) }
559  QVARID         { L _ (ITqvarid   _) }
560  QCONID         { L _ (ITqconid   _) }
561  QVARSYM        { L _ (ITqvarsym  _) }
562  QCONSYM        { L _ (ITqconsym  _) }
563
564  IPDUPVARID     { L _ (ITdupipvarid   _) }              -- GHC extension
565  LABELVARID     { L _ (ITlabelvarid   _) }
566
567  CHAR           { L _ (ITchar   _ _) }
568  STRING         { L _ (ITstring _ _) }
569  INTEGER        { L _ (ITinteger _) }
570  RATIONAL       { L _ (ITrational _) }
571
572  PRIMCHAR       { L _ (ITprimchar   _ _) }
573  PRIMSTRING     { L _ (ITprimstring _ _) }
574  PRIMINTEGER    { L _ (ITprimint    _ _) }
575  PRIMWORD       { L _ (ITprimword   _ _) }
576  PRIMFLOAT      { L _ (ITprimfloat  _) }
577  PRIMDOUBLE     { L _ (ITprimdouble _) }
578
579  DOCNEXT        { L _ (ITdocCommentNext _) }
580  DOCPREV        { L _ (ITdocCommentPrev _) }
581  DOCNAMED       { L _ (ITdocCommentNamed _) }
582  DOCSECTION     { L _ (ITdocSection _ _) }
583
584 -- Template Haskell
585 '[|'            { L _ (ITopenExpQuote _ _) }
586 '[p|'           { L _ ITopenPatQuote  }
587 '[t|'           { L _ ITopenTypQuote  }
588 '[d|'           { L _ ITopenDecQuote  }
589 '|]'            { L _ (ITcloseQuote _) }
590 '[||'           { L _ (ITopenTExpQuote _) }
591 '||]'           { L _ ITcloseTExpQuote  }
592 TH_ID_SPLICE    { L _ (ITidEscape _)  }     -- $x
593 '$('            { L _ ITparenEscape   }     -- $( exp )
594 TH_ID_TY_SPLICE { L _ (ITidTyEscape _)  }   -- $$x
595 '$$('           { L _ ITparenTyEscape   }   -- $$( exp )
596 TH_TY_QUOTE     { L _ ITtyQuote       }      -- ''T
597 TH_QUASIQUOTE   { L _ (ITquasiQuote _) }
598 TH_QQUASIQUOTE  { L _ (ITqQuasiQuote _) }
599
600 %monad { P } { >>= } { return }
601 %lexer { (lexer True) } { L _ ITeof }
602 %tokentype { (Located Token) }
603
604 -- Exported parsers
605 %name parseModule module
606 %name parseSignature signature
607 %name parseImport importdecl
608 %name parseStatement stmt
609 %name parseDeclaration topdecl
610 %name parseExpression exp
611 %name parsePattern pat
612 %name parseTypeSignature sigdecl
613 %name parseStmt   maybe_stmt
614 %name parseIdentifier  identifier
615 %name parseType ctype
616 %name parseBackpack backpack
617 %partial parseHeader header
618 %%
619
620 -----------------------------------------------------------------------------
621 -- Identifiers; one of the entry points
622 identifier :: { Located RdrName }
623         : qvar                          { $1 }
624         | qcon                          { $1 }
625         | qvarop                        { $1 }
626         | qconop                        { $1 }
627     | '(' '->' ')'      {% ams (sLL $1 $> $ getRdrName funTyCon)
628                                [mj AnnOpenP $1,mu AnnRarrow $2,mj AnnCloseP $3] }
629
630 -----------------------------------------------------------------------------
631 -- Backpack stuff
632
633 backpack :: { [LHsUnit PackageName] }
634          : implicit_top units close { fromOL $2 }
635          | '{' units '}'            { fromOL $2 }
636
637 units :: { OrdList (LHsUnit PackageName) }
638          : units ';' unit { $1 `appOL` unitOL $3 }
639          | units ';'      { $1 }
640          | unit           { unitOL $1 }
641
642 unit :: { LHsUnit PackageName }
643         : 'unit' pkgname 'where' unitbody
644             { sL1 $1 $ HsUnit { hsunitName = $2
645                               , hsunitBody = fromOL $4 } }
646
647 unitid :: { LHsUnitId PackageName }
648         : pkgname                  { sL1 $1 $ HsUnitId $1 [] }
649         | pkgname '[' msubsts ']'  { sLL $1 $> $ HsUnitId $1 (fromOL $3) }
650
651 msubsts :: { OrdList (LHsModuleSubst PackageName) }
652         : msubsts ',' msubst { $1 `appOL` unitOL $3 }
653         | msubsts ','        { $1 }
654         | msubst             { unitOL $1 }
655
656 msubst :: { LHsModuleSubst PackageName }
657         : modid '=' moduleid { sLL $1 $> $ ($1, $3) }
658         | modid VARSYM modid VARSYM { sLL $1 $> $ ($1, sLL $2 $> $ HsModuleVar $3) }
659
660 moduleid :: { LHsModuleId PackageName }
661           : VARSYM modid VARSYM { sLL $1 $> $ HsModuleVar $2 }
662           | unitid ':' modid    { sLL $1 $> $ HsModuleId $1 $3 }
663
664 pkgname :: { Located PackageName }
665         : STRING     { sL1 $1 $ PackageName (getSTRING $1) }
666         | litpkgname { sL1 $1 $ PackageName (unLoc $1) }
667
668 litpkgname_segment :: { Located FastString }
669         : VARID  { sL1 $1 $ getVARID $1 }
670         | CONID  { sL1 $1 $ getCONID $1 }
671         | special_id { $1 }
672
673 litpkgname :: { Located FastString }
674         : litpkgname_segment { $1 }
675         -- a bit of a hack, means p - b is parsed same as p-b, enough for now.
676         | litpkgname_segment '-' litpkgname  { sLL $1 $> $ appendFS (unLoc $1) (consFS '-' (unLoc $3)) }
677
678 mayberns :: { Maybe [LRenaming] }
679         : {- empty -} { Nothing }
680         | '(' rns ')' { Just (fromOL $2) }
681
682 rns :: { OrdList LRenaming }
683         : rns ',' rn { $1 `appOL` unitOL $3 }
684         | rns ','    { $1 }
685         | rn         { unitOL $1 }
686
687 rn :: { LRenaming }
688         : modid 'as' modid { sLL $1 $> $ Renaming $1 (Just $3) }
689         | modid            { sL1 $1    $ Renaming $1 Nothing }
690
691 unitbody :: { OrdList (LHsUnitDecl PackageName) }
692         : '{'     unitdecls '}'   { $2 }
693         | vocurly unitdecls close { $2 }
694
695 unitdecls :: { OrdList (LHsUnitDecl PackageName) }
696         : unitdecls ';' unitdecl { $1 `appOL` unitOL $3 }
697         | unitdecls ';'         { $1 }
698         | unitdecl              { unitOL $1 }
699
700 unitdecl :: { LHsUnitDecl PackageName }
701         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' body
702              -- XXX not accurate
703              { sL1 $2 $ DeclD ModuleD $3 (Just (sL1 $2 (HsModule (Just $3) $5 (fst $ snd $7) (snd $ snd $7) $4 $1))) }
704         | maybedocheader 'signature' modid maybemodwarning maybeexports 'where' body
705              { sL1 $2 $ DeclD SignatureD $3 (Just (sL1 $2 (HsModule (Just $3) $5 (fst $ snd $7) (snd $ snd $7) $4 $1))) }
706         -- NB: MUST have maybedocheader here, otherwise shift-reduce conflict
707         -- will prevent us from parsing both forms.
708         | maybedocheader 'module' modid
709              { sL1 $2 $ DeclD ModuleD $3 Nothing }
710         | maybedocheader 'signature' modid
711              { sL1 $2 $ DeclD SignatureD $3 Nothing }
712         | 'dependency' unitid mayberns
713              { sL1 $1 $ IncludeD (IncludeDecl { idUnitId = $2
714                                               , idModRenaming = $3
715                                               , idSignatureInclude = False }) }
716         | 'dependency' 'signature' unitid
717              { sL1 $1 $ IncludeD (IncludeDecl { idUnitId = $3
718                                               , idModRenaming = Nothing
719                                               , idSignatureInclude = True }) }
720
721 -----------------------------------------------------------------------------
722 -- Module Header
723
724 -- The place for module deprecation is really too restrictive, but if it
725 -- was allowed at its natural place just before 'module', we get an ugly
726 -- s/r conflict with the second alternative. Another solution would be the
727 -- introduction of a new pragma DEPRECATED_MODULE, but this is not very nice,
728 -- either, and DEPRECATED is only expected to be used by people who really
729 -- know what they are doing. :-)
730
731 signature :: { Located (HsModule GhcPs) }
732        : maybedocheader 'signature' modid maybemodwarning maybeexports 'where' body
733              {% fileSrcSpan >>= \ loc ->
734                 ams (L loc (HsModule (Just $3) $5 (fst $ snd $7)
735                               (snd $ snd $7) $4 $1)
736                     )
737                     ([mj AnnSignature $2, mj AnnWhere $6] ++ fst $7) }
738
739 module :: { Located (HsModule GhcPs) }
740        : maybedocheader 'module' modid maybemodwarning maybeexports 'where' body
741              {% fileSrcSpan >>= \ loc ->
742                 ams (L loc (HsModule (Just $3) $5 (fst $ snd $7)
743                               (snd $ snd $7) $4 $1)
744                     )
745                     ([mj AnnModule $2, mj AnnWhere $6] ++ fst $7) }
746         | body2
747                 {% fileSrcSpan >>= \ loc ->
748                    ams (L loc (HsModule Nothing Nothing
749                                (fst $ snd $1) (snd $ snd $1) Nothing Nothing))
750                        (fst $1) }
751
752 maybedocheader :: { Maybe LHsDocString }
753         : moduleheader            { $1 }
754         | {- empty -}             { Nothing }
755
756 missing_module_keyword :: { () }
757         : {- empty -}                           {% pushModuleContext }
758
759 implicit_top :: { () }
760         : {- empty -}                           {% pushModuleContext }
761
762 maybemodwarning :: { Maybe (Located WarningTxt) }
763     : '{-# DEPRECATED' strings '#-}'
764                       {% ajs (Just (sLL $1 $> $ DeprecatedTxt (sL1 $1 (getDEPRECATED_PRAGs $1)) (snd $ unLoc $2)))
765                              (mo $1:mc $3: (fst $ unLoc $2)) }
766     | '{-# WARNING' strings '#-}'
767                          {% ajs (Just (sLL $1 $> $ WarningTxt (sL1 $1 (getWARNING_PRAGs $1)) (snd $ unLoc $2)))
768                                 (mo $1:mc $3 : (fst $ unLoc $2)) }
769     |  {- empty -}                  { Nothing }
770
771 body    :: { ([AddAnn]
772              ,([LImportDecl GhcPs], [LHsDecl GhcPs])) }
773         :  '{'            top '}'      { (moc $1:mcc $3:(fst $2)
774                                          , snd $2) }
775         |      vocurly    top close    { (fst $2, snd $2) }
776
777 body2   :: { ([AddAnn]
778              ,([LImportDecl GhcPs], [LHsDecl GhcPs])) }
779         :  '{' top '}'                          { (moc $1:mcc $3
780                                                    :(fst $2), snd $2) }
781         |  missing_module_keyword top close     { ([],snd $2) }
782
783
784 top     :: { ([AddAnn]
785              ,([LImportDecl GhcPs], [LHsDecl GhcPs])) }
786         : semis top1                            { ($1, $2) }
787
788 top1    :: { ([LImportDecl GhcPs], [LHsDecl GhcPs]) }
789         : importdecls_semi topdecls_semi        { (reverse $1, cvTopDecls $2) }
790         | importdecls_semi topdecls             { (reverse $1, cvTopDecls $2) }
791         | importdecls                           { (reverse $1, []) }
792
793 -----------------------------------------------------------------------------
794 -- Module declaration & imports only
795
796 header  :: { Located (HsModule GhcPs) }
797         : maybedocheader 'module' modid maybemodwarning maybeexports 'where' header_body
798                 {% fileSrcSpan >>= \ loc ->
799                    ams (L loc (HsModule (Just $3) $5 $7 [] $4 $1
800                           )) [mj AnnModule $2,mj AnnWhere $6] }
801         | maybedocheader 'signature' modid maybemodwarning maybeexports 'where' header_body
802                 {% fileSrcSpan >>= \ loc ->
803                    ams (L loc (HsModule (Just $3) $5 $7 [] $4 $1
804                           )) [mj AnnModule $2,mj AnnWhere $6] }
805         | header_body2
806                 {% fileSrcSpan >>= \ loc ->
807                    return (L loc (HsModule Nothing Nothing $1 [] Nothing
808                           Nothing)) }
809
810 header_body :: { [LImportDecl GhcPs] }
811         :  '{'            header_top            { $2 }
812         |      vocurly    header_top            { $2 }
813
814 header_body2 :: { [LImportDecl GhcPs] }
815         :  '{' header_top                       { $2 }
816         |  missing_module_keyword header_top    { $2 }
817
818 header_top :: { [LImportDecl GhcPs] }
819         :  semis header_top_importdecls         { $2 }
820
821 header_top_importdecls :: { [LImportDecl GhcPs] }
822         :  importdecls_semi                     { $1 }
823         |  importdecls                          { $1 }
824
825 -----------------------------------------------------------------------------
826 -- The Export List
827
828 maybeexports :: { (Maybe (Located [LIE GhcPs])) }
829         :  '(' exportlist ')'       {% ams (sLL $1 $> ()) [mop $1,mcp $3] >>
830                                        return (Just (sLL $1 $> (fromOL $2))) }
831         |  {- empty -}              { Nothing }
832
833 exportlist :: { OrdList (LIE GhcPs) }
834         : expdoclist ',' expdoclist   {% addAnnotation (oll $1) AnnComma (gl $2)
835                                          >> return ($1 `appOL` $3) }
836         | exportlist1                 { $1 }
837
838 exportlist1 :: { OrdList (LIE GhcPs) }
839         : expdoclist export expdoclist ',' exportlist1
840                           {% (addAnnotation (oll ($1 `appOL` $2 `appOL` $3))
841                                             AnnComma (gl $4) ) >>
842                               return ($1 `appOL` $2 `appOL` $3 `appOL` $5) }
843         | expdoclist export expdoclist             { $1 `appOL` $2 `appOL` $3 }
844         | expdoclist                               { $1 }
845
846 expdoclist :: { OrdList (LIE GhcPs) }
847         : exp_doc expdoclist                           { $1 `appOL` $2 }
848         | {- empty -}                                  { nilOL }
849
850 exp_doc :: { OrdList (LIE GhcPs) }
851         : docsection    { unitOL (sL1 $1 (case (unLoc $1) of (n, doc) -> IEGroup noExt n doc)) }
852         | docnamed      { unitOL (sL1 $1 (IEDocNamed noExt ((fst . unLoc) $1))) }
853         | docnext       { unitOL (sL1 $1 (IEDoc noExt (unLoc $1))) }
854
855
856    -- No longer allow things like [] and (,,,) to be exported
857    -- They are built in syntax, always available
858 export  :: { OrdList (LIE GhcPs) }
859         : qcname_ext export_subspec  {% mkModuleImpExp $1 (snd $ unLoc $2)
860                                           >>= \ie -> amsu (sLL $1 $> ie) (fst $ unLoc $2) }
861         |  'module' modid            {% amsu (sLL $1 $> (IEModuleContents noExt $2))
862                                              [mj AnnModule $1] }
863         |  'pattern' qcon            {% amsu (sLL $1 $> (IEVar noExt (sLL $1 $> (IEPattern $2))))
864                                              [mj AnnPattern $1] }
865
866 export_subspec :: { Located ([AddAnn],ImpExpSubSpec) }
867         : {- empty -}             { sL0 ([],ImpExpAbs) }
868         | '(' qcnames ')'         {% mkImpExpSubSpec (reverse (snd $2))
869                                       >>= \(as,ie) -> return $ sLL $1 $>
870                                             (as ++ [mop $1,mcp $3] ++ fst $2, ie) }
871
872
873 qcnames :: { ([AddAnn], [Located ImpExpQcSpec]) }
874   : {- empty -}                   { ([],[]) }
875   | qcnames1                      { $1 }
876
877 qcnames1 :: { ([AddAnn], [Located ImpExpQcSpec]) }     -- A reversed list
878         :  qcnames1 ',' qcname_ext_w_wildcard  {% case (head (snd $1)) of
879                                                     l@(L _ ImpExpQcWildcard) ->
880                                                        return ([mj AnnComma $2, mj AnnDotdot l]
881                                                                ,(snd (unLoc $3)  : snd $1))
882                                                     l -> (ams (head (snd $1)) [mj AnnComma $2] >>
883                                                           return (fst $1 ++ fst (unLoc $3),
884                                                                   snd (unLoc $3) : snd $1)) }
885
886
887         -- Annotations re-added in mkImpExpSubSpec
888         |  qcname_ext_w_wildcard                   { (fst (unLoc $1),[snd (unLoc $1)]) }
889
890 -- Variable, data constructor or wildcard
891 -- or tagged type constructor
892 qcname_ext_w_wildcard :: { Located ([AddAnn], Located ImpExpQcSpec) }
893         :  qcname_ext               { sL1 $1 ([],$1) }
894         |  '..'                     { sL1 $1 ([mj AnnDotdot $1], sL1 $1 ImpExpQcWildcard)  }
895
896 qcname_ext :: { Located ImpExpQcSpec }
897         :  qcname                   { sL1 $1 (ImpExpQcName $1) }
898         |  'type' oqtycon           {% do { n <- mkTypeImpExp $2
899                                           ; ams (sLL $1 $> (ImpExpQcType n))
900                                                 [mj AnnType $1] } }
901
902 qcname  :: { Located RdrName }  -- Variable or type constructor
903         :  qvar                 { $1 } -- Things which look like functions
904                                        -- Note: This includes record selectors but
905                                        -- also (-.->), see #11432
906         |  oqtycon_no_varcon    { $1 } -- see Note [Type constructors in export list]
907
908 -----------------------------------------------------------------------------
909 -- Import Declarations
910
911 -- importdecls and topdecls must contain at least one declaration;
912 -- top handles the fact that these may be optional.
913
914 -- One or more semicolons
915 semis1  :: { [AddAnn] }
916 semis1  : semis1 ';'  { mj AnnSemi $2 : $1 }
917         | ';'         { [mj AnnSemi $1] }
918
919 -- Zero or more semicolons
920 semis   :: { [AddAnn] }
921 semis   : semis ';'   { mj AnnSemi $2 : $1 }
922         | {- empty -} { [] }
923
924 -- No trailing semicolons, non-empty
925 importdecls :: { [LImportDecl GhcPs] }
926 importdecls
927         : importdecls_semi importdecl
928                                 { $2 : $1 }
929
930 -- May have trailing semicolons, can be empty
931 importdecls_semi :: { [LImportDecl GhcPs] }
932 importdecls_semi
933         : importdecls_semi importdecl semis1
934                                 {% ams $2 $3 >> return ($2 : $1) }
935         | {- empty -}           { [] }
936
937 importdecl :: { LImportDecl GhcPs }
938         : 'import' maybe_src maybe_safe optqualified maybe_pkg modid maybeas maybeimpspec
939                 {% ams (L (comb4 $1 $6 (snd $7) $8) $
940                   ImportDecl { ideclExt = noExt
941                              , ideclSourceSrc = snd $ fst $2
942                              , ideclName = $6, ideclPkgQual = snd $5
943                              , ideclSource = snd $2, ideclSafe = snd $3
944                              , ideclQualified = snd $4, ideclImplicit = False
945                              , ideclAs = unLoc (snd $7)
946                              , ideclHiding = unLoc $8 })
947                    ((mj AnnImport $1 : (fst $ fst $2) ++ fst $3 ++ fst $4
948                                     ++ fst $5 ++ fst $7)) }
949
950 maybe_src :: { (([AddAnn],SourceText),IsBootInterface) }
951         : '{-# SOURCE' '#-}'        { (([mo $1,mc $2],getSOURCE_PRAGs $1)
952                                       ,True) }
953         | {- empty -}               { (([],NoSourceText),False) }
954
955 maybe_safe :: { ([AddAnn],Bool) }
956         : 'safe'                                { ([mj AnnSafe $1],True) }
957         | {- empty -}                           { ([],False) }
958
959 maybe_pkg :: { ([AddAnn],Maybe StringLiteral) }
960         : STRING  {% let pkgFS = getSTRING $1 in
961                      if looksLikePackageName (unpackFS pkgFS)
962                         then return ([mj AnnPackageName $1], Just (StringLiteral (getSTRINGs $1) pkgFS))
963                         else parseErrorSDoc (getLoc $1) $ vcat [
964                              text "parse error" <> colon <+> quotes (ppr pkgFS),
965                              text "Version number or non-alphanumeric" <+>
966                              text "character in package name"] }
967         | {- empty -}                           { ([],Nothing) }
968
969 optqualified :: { ([AddAnn],Bool) }
970         : 'qualified'                           { ([mj AnnQualified $1],True)  }
971         | {- empty -}                           { ([],False) }
972
973 maybeas :: { ([AddAnn],Located (Maybe (Located ModuleName))) }
974         : 'as' modid                           { ([mj AnnAs $1]
975                                                  ,sLL $1 $> (Just $2)) }
976         | {- empty -}                          { ([],noLoc Nothing) }
977
978 maybeimpspec :: { Located (Maybe (Bool, Located [LIE GhcPs])) }
979         : impspec                  {% let (b, ie) = unLoc $1 in
980                                        checkImportSpec ie
981                                         >>= \checkedIe ->
982                                           return (L (gl $1) (Just (b, checkedIe)))  }
983         | {- empty -}              { noLoc Nothing }
984
985 impspec :: { Located (Bool, Located [LIE GhcPs]) }
986         :  '(' exportlist ')'               {% ams (sLL $1 $> (False,
987                                                       sLL $1 $> $ fromOL $2))
988                                                    [mop $1,mcp $3] }
989         |  'hiding' '(' exportlist ')'      {% ams (sLL $1 $> (True,
990                                                       sLL $1 $> $ fromOL $3))
991                                                [mj AnnHiding $1,mop $2,mcp $4] }
992
993 -----------------------------------------------------------------------------
994 -- Fixity Declarations
995
996 prec    :: { Located (SourceText,Int) }
997         : {- empty -}           { noLoc (NoSourceText,9) }
998         | INTEGER
999                  {% checkPrecP (sL1 $1 (getINTEGERs $1,fromInteger (il_value (getINTEGER $1)))) }
1000
1001 infix   :: { Located FixityDirection }
1002         : 'infix'                               { sL1 $1 InfixN  }
1003         | 'infixl'                              { sL1 $1 InfixL  }
1004         | 'infixr'                              { sL1 $1 InfixR }
1005
1006 ops     :: { Located (OrdList (Located RdrName)) }
1007         : ops ',' op       {% addAnnotation (oll $ unLoc $1) AnnComma (gl $2) >>
1008                               return (sLL $1 $> ((unLoc $1) `appOL` unitOL $3))}
1009         | op               { sL1 $1 (unitOL $1) }
1010
1011 -----------------------------------------------------------------------------
1012 -- Top-Level Declarations
1013
1014 -- No trailing semicolons, non-empty
1015 topdecls :: { OrdList (LHsDecl GhcPs) }
1016         : topdecls_semi topdecl        { $1 `snocOL` $2 }
1017
1018 -- May have trailing semicolons, can be empty
1019 topdecls_semi :: { OrdList (LHsDecl GhcPs) }
1020         : topdecls_semi topdecl semis1 {% ams $2 $3 >> return ($1 `snocOL` $2) }
1021         | {- empty -}                  { nilOL }
1022
1023 topdecl :: { LHsDecl GhcPs }
1024         : cl_decl                               { sL1 $1 (TyClD noExt (unLoc $1)) }
1025         | ty_decl                               { sL1 $1 (TyClD noExt (unLoc $1)) }
1026         | inst_decl                             { sL1 $1 (InstD noExt (unLoc $1)) }
1027         | stand_alone_deriving                  { sLL $1 $> (DerivD noExt (unLoc $1)) }
1028         | role_annot                            { sL1 $1 (RoleAnnotD noExt (unLoc $1)) }
1029         | 'default' '(' comma_types0 ')'    {% ams (sLL $1 $> (DefD noExt (DefaultDecl noExt $3)))
1030                                                          [mj AnnDefault $1
1031                                                          ,mop $2,mcp $4] }
1032         | 'foreign' fdecl          {% ams (sLL $1 $> (snd $ unLoc $2))
1033                                            (mj AnnForeign $1:(fst $ unLoc $2)) }
1034         | '{-# DEPRECATED' deprecations '#-}'   {% ams (sLL $1 $> $ WarningD noExt (Warnings noExt (getDEPRECATED_PRAGs $1) (fromOL $2)))
1035                                                        [mo $1,mc $3] }
1036         | '{-# WARNING' warnings '#-}'          {% ams (sLL $1 $> $ WarningD noExt (Warnings noExt (getWARNING_PRAGs $1) (fromOL $2)))
1037                                                        [mo $1,mc $3] }
1038         | '{-# RULES' rules '#-}'               {% ams (sLL $1 $> $ RuleD noExt (HsRules noExt (getRULES_PRAGs $1) (fromOL $2)))
1039                                                        [mo $1,mc $3] }
1040         | annotation { $1 }
1041         | decl_no_th                            { $1 }
1042
1043         -- Template Haskell Extension
1044         -- The $(..) form is one possible form of infixexp
1045         -- but we treat an arbitrary expression just as if
1046         -- it had a $(..) wrapped around it
1047         | infixexp_top                          { sLL $1 $> $ mkSpliceDecl $1 }
1048
1049 -- Type classes
1050 --
1051 cl_decl :: { LTyClDecl GhcPs }
1052         : 'class' tycl_hdr fds where_cls
1053                 {% amms (mkClassDecl (comb4 $1 $2 $3 $4) $2 $3 (snd $ unLoc $4))
1054                         (mj AnnClass $1:(fst $ unLoc $3)++(fst $ unLoc $4)) }
1055
1056 -- Type declarations (toplevel)
1057 --
1058 ty_decl :: { LTyClDecl GhcPs }
1059            -- ordinary type synonyms
1060         : 'type' type '=' ctypedoc
1061                 -- Note ctype, not sigtype, on the right of '='
1062                 -- We allow an explicit for-all but we don't insert one
1063                 -- in   type Foo a = (b,b)
1064                 -- Instead we just say b is out of scope
1065                 --
1066                 -- Note the use of type for the head; this allows
1067                 -- infix type constructors to be declared
1068                 {% amms (mkTySynonym (comb2 $1 $4) $2 $4)
1069                         [mj AnnType $1,mj AnnEqual $3] }
1070
1071            -- type family declarations
1072         | 'type' 'family' type opt_tyfam_kind_sig opt_injective_info
1073                           where_type_family
1074                 -- Note the use of type for the head; this allows
1075                 -- infix type constructors to be declared
1076                 {% amms (mkFamDecl (comb4 $1 $3 $4 $5) (snd $ unLoc $6) $3
1077                                    (snd $ unLoc $4) (snd $ unLoc $5))
1078                         (mj AnnType $1:mj AnnFamily $2:(fst $ unLoc $4)
1079                            ++ (fst $ unLoc $5) ++ (fst $ unLoc $6)) }
1080
1081           -- ordinary data type or newtype declaration
1082         | data_or_newtype capi_ctype tycl_hdr constrs maybe_derivings
1083                 {% amms (mkTyData (comb4 $1 $3 $4 $5) (snd $ unLoc $1) $2 $3
1084                            Nothing (reverse (snd $ unLoc $4))
1085                                    (fmap reverse $5))
1086                                    -- We need the location on tycl_hdr in case
1087                                    -- constrs and deriving are both empty
1088                         ((fst $ unLoc $1):(fst $ unLoc $4)) }
1089
1090           -- ordinary GADT declaration
1091         | data_or_newtype capi_ctype tycl_hdr opt_kind_sig
1092                  gadt_constrlist
1093                  maybe_derivings
1094             {% amms (mkTyData (comb4 $1 $3 $5 $6) (snd $ unLoc $1) $2 $3
1095                             (snd $ unLoc $4) (snd $ unLoc $5)
1096                             (fmap reverse $6) )
1097                                    -- We need the location on tycl_hdr in case
1098                                    -- constrs and deriving are both empty
1099                     ((fst $ unLoc $1):(fst $ unLoc $4)++(fst $ unLoc $5)) }
1100
1101           -- data/newtype family
1102         | 'data' 'family' type opt_datafam_kind_sig
1103                 {% amms (mkFamDecl (comb3 $1 $2 $4) DataFamily $3
1104                                    (snd $ unLoc $4) Nothing)
1105                         (mj AnnData $1:mj AnnFamily $2:(fst $ unLoc $4)) }
1106
1107 inst_decl :: { LInstDecl GhcPs }
1108         : 'instance' overlap_pragma inst_type where_inst
1109        {% do { (binds, sigs, _, ats, adts, _) <- cvBindsAndSigs (snd $ unLoc $4)
1110              ; let cid = ClsInstDecl { cid_ext = noExt
1111                                      , cid_poly_ty = $3, cid_binds = binds
1112                                      , cid_sigs = mkClassOpSigs sigs
1113                                      , cid_tyfam_insts = ats
1114                                      , cid_overlap_mode = $2
1115                                      , cid_datafam_insts = adts }
1116              ; ams (L (comb3 $1 (hsSigType $3) $4) (ClsInstD { cid_d_ext = noExt, cid_inst = cid }))
1117                    (mj AnnInstance $1 : (fst $ unLoc $4)) } }
1118
1119            -- type instance declarations
1120         | 'type' 'instance' ty_fam_inst_eqn
1121                 {% ams $3 (fst $ unLoc $3)
1122                 >> amms (mkTyFamInst (comb2 $1 $3) (snd $ unLoc $3))
1123                     (mj AnnType $1:mj AnnInstance $2:(fst $ unLoc $3)) }
1124
1125           -- data/newtype instance declaration
1126         | data_or_newtype 'instance' capi_ctype tycl_hdr constrs
1127                           maybe_derivings
1128             {% amms (mkDataFamInst (comb4 $1 $4 $5 $6) (snd $ unLoc $1) $3 $4
1129                                       Nothing (reverse (snd  $ unLoc $5))
1130                                               (fmap reverse $6))
1131                     ((fst $ unLoc $1):mj AnnInstance $2:(fst $ unLoc $5)) }
1132
1133           -- GADT instance declaration
1134         | data_or_newtype 'instance' capi_ctype tycl_hdr opt_kind_sig
1135                  gadt_constrlist
1136                  maybe_derivings
1137             {% amms (mkDataFamInst (comb4 $1 $4 $6 $7) (snd $ unLoc $1) $3 $4
1138                                    (snd $ unLoc $5) (snd $ unLoc $6)
1139                                    (fmap reverse $7))
1140                     ((fst $ unLoc $1):mj AnnInstance $2
1141                        :(fst $ unLoc $5)++(fst $ unLoc $6)) }
1142
1143 overlap_pragma :: { Maybe (Located OverlapMode) }
1144   : '{-# OVERLAPPABLE'    '#-}' {% ajs (Just (sLL $1 $> (Overlappable (getOVERLAPPABLE_PRAGs $1))))
1145                                        [mo $1,mc $2] }
1146   | '{-# OVERLAPPING'     '#-}' {% ajs (Just (sLL $1 $> (Overlapping (getOVERLAPPING_PRAGs $1))))
1147                                        [mo $1,mc $2] }
1148   | '{-# OVERLAPS'        '#-}' {% ajs (Just (sLL $1 $> (Overlaps (getOVERLAPS_PRAGs $1))))
1149                                        [mo $1,mc $2] }
1150   | '{-# INCOHERENT'      '#-}' {% ajs (Just (sLL $1 $> (Incoherent (getINCOHERENT_PRAGs $1))))
1151                                        [mo $1,mc $2] }
1152   | {- empty -}                 { Nothing }
1153
1154 deriv_strategy_no_via :: { LDerivStrategy GhcPs }
1155   : 'stock'                     {% ams (sL1 $1 StockStrategy)
1156                                        [mj AnnStock $1] }
1157   | 'anyclass'                  {% ams (sL1 $1 AnyclassStrategy)
1158                                        [mj AnnAnyclass $1] }
1159   | 'newtype'                   {% ams (sL1 $1 NewtypeStrategy)
1160                                        [mj AnnNewtype $1] }
1161
1162 deriv_strategy_via :: { LDerivStrategy GhcPs }
1163   : 'via' tyapp                 {% splitTildeApps [$2] >>= \tys -> let
1164                                      ty :: LHsType GhcPs
1165                                      ty = sL1 $1 $ mkHsAppsTy tys
1166
1167                                      in ams (sLL $1 $> (ViaStrategy (mkLHsSigType ty)))
1168                                             [mj AnnVia $1] }
1169
1170 deriv_standalone_strategy :: { Maybe (LDerivStrategy GhcPs) }
1171   : 'stock'                     {% ajs (Just (sL1 $1 StockStrategy))
1172                                        [mj AnnStock $1] }
1173   | 'anyclass'                  {% ajs (Just (sL1 $1 AnyclassStrategy))
1174                                        [mj AnnAnyclass $1] }
1175   | 'newtype'                   {% ajs (Just (sL1 $1 NewtypeStrategy))
1176                                        [mj AnnNewtype $1] }
1177   | deriv_strategy_via          { Just $1 }
1178   | {- empty -}                 { Nothing }
1179
1180 -- Injective type families
1181
1182 opt_injective_info :: { Located ([AddAnn], Maybe (LInjectivityAnn GhcPs)) }
1183         : {- empty -}               { noLoc ([], Nothing) }
1184         | '|' injectivity_cond      { sLL $1 $> ([mj AnnVbar $1]
1185                                                 , Just ($2)) }
1186
1187 injectivity_cond :: { LInjectivityAnn GhcPs }
1188         : tyvarid '->' inj_varids
1189            {% ams (sLL $1 $> (InjectivityAnn $1 (reverse (unLoc $3))))
1190                   [mu AnnRarrow $2] }
1191
1192 inj_varids :: { Located [Located RdrName] }
1193         : inj_varids tyvarid  { sLL $1 $> ($2 : unLoc $1) }
1194         | tyvarid             { sLL $1 $> [$1]            }
1195
1196 -- Closed type families
1197
1198 where_type_family :: { Located ([AddAnn],FamilyInfo GhcPs) }
1199         : {- empty -}                      { noLoc ([],OpenTypeFamily) }
1200         | 'where' ty_fam_inst_eqn_list
1201                { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)
1202                     ,ClosedTypeFamily (fmap reverse $ snd $ unLoc $2)) }
1203
1204 ty_fam_inst_eqn_list :: { Located ([AddAnn],Maybe [LTyFamInstEqn GhcPs]) }
1205         :     '{' ty_fam_inst_eqns '}'     { sLL $1 $> ([moc $1,mcc $3]
1206                                                 ,Just (unLoc $2)) }
1207         | vocurly ty_fam_inst_eqns close   { let L loc _ = $2 in
1208                                              L loc ([],Just (unLoc $2)) }
1209         |     '{' '..' '}'                 { sLL $1 $> ([moc $1,mj AnnDotdot $2
1210                                                  ,mcc $3],Nothing) }
1211         | vocurly '..' close               { let L loc _ = $2 in
1212                                              L loc ([mj AnnDotdot $2],Nothing) }
1213
1214 ty_fam_inst_eqns :: { Located [LTyFamInstEqn GhcPs] }
1215         : ty_fam_inst_eqns ';' ty_fam_inst_eqn
1216                                       {% let L loc (anns, eqn) = $3 in
1217                                          asl (unLoc $1) $2 (L loc eqn)
1218                                          >> ams $3 anns
1219                                          >> return (sLL $1 $> (L loc eqn : unLoc $1)) }
1220         | ty_fam_inst_eqns ';'        {% addAnnotation (gl $1) AnnSemi (gl $2)
1221                                          >> return (sLL $1 $>  (unLoc $1)) }
1222         | ty_fam_inst_eqn             {% let L loc (anns, eqn) = $1 in
1223                                          ams $1 anns
1224                                          >> return (sLL $1 $> [L loc eqn]) }
1225         | {- empty -}                 { noLoc [] }
1226
1227 ty_fam_inst_eqn :: { Located ([AddAnn],TyFamInstEqn GhcPs) }
1228         : type '=' ctype
1229                 -- Note the use of type for the head; this allows
1230                 -- infix type constructors and type patterns
1231               {% do { (eqn,ann) <- mkTyFamInstEqn $1 $3
1232                     ; return (sLL $1 $> (mj AnnEqual $2:ann, eqn))  } }
1233
1234 -- Associated type family declarations
1235 --
1236 -- * They have a different syntax than on the toplevel (no family special
1237 --   identifier).
1238 --
1239 -- * They also need to be separate from instances; otherwise, data family
1240 --   declarations without a kind signature cause parsing conflicts with empty
1241 --   data declarations.
1242 --
1243 at_decl_cls :: { LHsDecl GhcPs }
1244         :  -- data family declarations, with optional 'family' keyword
1245           'data' opt_family type opt_datafam_kind_sig
1246                 {% amms (liftM mkTyClD (mkFamDecl (comb3 $1 $3 $4) DataFamily $3
1247                                                   (snd $ unLoc $4) Nothing))
1248                         (mj AnnData $1:$2++(fst $ unLoc $4)) }
1249
1250            -- type family declarations, with optional 'family' keyword
1251            -- (can't use opt_instance because you get shift/reduce errors
1252         | 'type' type opt_at_kind_inj_sig
1253                {% amms (liftM mkTyClD
1254                         (mkFamDecl (comb3 $1 $2 $3) OpenTypeFamily $2
1255                                    (fst . snd $ unLoc $3)
1256                                    (snd . snd $ unLoc $3)))
1257                        (mj AnnType $1:(fst $ unLoc $3)) }
1258         | 'type' 'family' type opt_at_kind_inj_sig
1259                {% amms (liftM mkTyClD
1260                         (mkFamDecl (comb3 $1 $3 $4) OpenTypeFamily $3
1261                                    (fst . snd $ unLoc $4)
1262                                    (snd . snd $ unLoc $4)))
1263                        (mj AnnType $1:mj AnnFamily $2:(fst $ unLoc $4)) }
1264
1265            -- default type instances, with optional 'instance' keyword
1266         | 'type' ty_fam_inst_eqn
1267                 {% ams $2 (fst $ unLoc $2) >>
1268                    amms (liftM mkInstD (mkTyFamInst (comb2 $1 $2) (snd $ unLoc $2)))
1269                         (mj AnnType $1:(fst $ unLoc $2)) }
1270         | 'type' 'instance' ty_fam_inst_eqn
1271                 {% ams $3 (fst $ unLoc $3) >>
1272                    amms (liftM mkInstD (mkTyFamInst (comb2 $1 $3) (snd $ unLoc $3)))
1273                         (mj AnnType $1:mj AnnInstance $2:(fst $ unLoc $3)) }
1274
1275 opt_family   :: { [AddAnn] }
1276               : {- empty -}   { [] }
1277               | 'family'      { [mj AnnFamily $1] }
1278
1279 opt_instance :: { [AddAnn] }
1280               : {- empty -} { [] }
1281               | 'instance'  { [mj AnnInstance $1] }
1282
1283 -- Associated type instances
1284 --
1285 at_decl_inst :: { LInstDecl GhcPs }
1286            -- type instance declarations, with optional 'instance' keyword
1287         : 'type' opt_instance ty_fam_inst_eqn
1288                 -- Note the use of type for the head; this allows
1289                 -- infix type constructors and type patterns
1290                 {% ams $3 (fst $ unLoc $3) >>
1291                    amms (mkTyFamInst (comb2 $1 $3) (snd $ unLoc $3))
1292                         (mj AnnType $1:$2++(fst $ unLoc $3)) }
1293
1294         -- data/newtype instance declaration, with optional 'instance' keyword
1295         -- (can't use opt_instance because you get reduce/reduce errors)
1296         | data_or_newtype capi_ctype tycl_hdr constrs maybe_derivings
1297                {% amms (mkDataFamInst (comb4 $1 $3 $4 $5) (snd $ unLoc $1) $2 $3
1298                                     Nothing (reverse (snd $ unLoc $4))
1299                                             (fmap reverse $5))
1300                        ((fst $ unLoc $1):(fst $ unLoc $4)) }
1301
1302         | data_or_newtype 'instance' capi_ctype tycl_hdr constrs maybe_derivings
1303                {% amms (mkDataFamInst (comb4 $1 $4 $5 $6) (snd $ unLoc $1) $3 $4
1304                                     Nothing (reverse (snd $ unLoc $5))
1305                                             (fmap reverse $6))
1306                        ((fst $ unLoc $1):mj AnnInstance $2:(fst $ unLoc $5)) }
1307
1308         -- GADT instance declaration, with optional 'instance' keyword
1309         -- (can't use opt_instance because you get reduce/reduce errors)
1310         | data_or_newtype capi_ctype tycl_hdr opt_kind_sig
1311                  gadt_constrlist
1312                  maybe_derivings
1313                 {% amms (mkDataFamInst (comb4 $1 $3 $5 $6) (snd $ unLoc $1) $2
1314                                 $3 (snd $ unLoc $4) (snd $ unLoc $5)
1315                                 (fmap reverse $6))
1316                         ((fst $ unLoc $1):(fst $ unLoc $4)++(fst $ unLoc $5)) }
1317
1318         | data_or_newtype 'instance' capi_ctype tycl_hdr opt_kind_sig
1319                  gadt_constrlist
1320                  maybe_derivings
1321                 {% amms (mkDataFamInst (comb4 $1 $4 $6 $7) (snd $ unLoc $1) $3
1322                                 $4 (snd $ unLoc $5) (snd $ unLoc $6)
1323                                 (fmap reverse $7))
1324                         ((fst $ unLoc $1):mj AnnInstance $2:(fst $ unLoc $5)++(fst $ unLoc $6)) }
1325
1326 data_or_newtype :: { Located (AddAnn, NewOrData) }
1327         : 'data'        { sL1 $1 (mj AnnData    $1,DataType) }
1328         | 'newtype'     { sL1 $1 (mj AnnNewtype $1,NewType) }
1329
1330 -- Family result/return kind signatures
1331
1332 opt_kind_sig :: { Located ([AddAnn], Maybe (LHsKind GhcPs)) }
1333         :               { noLoc     ([]               , Nothing) }
1334         | '::' kind     { sLL $1 $> ([mu AnnDcolon $1], Just $2) }
1335
1336 opt_datafam_kind_sig :: { Located ([AddAnn], LFamilyResultSig GhcPs) }
1337         :               { noLoc     ([]               , noLoc (NoSig noExt)         )}
1338         | '::' kind     { sLL $1 $> ([mu AnnDcolon $1], sLL $1 $> (KindSig noExt $2))}
1339
1340 opt_tyfam_kind_sig :: { Located ([AddAnn], LFamilyResultSig GhcPs) }
1341         :              { noLoc     ([]               , noLoc     (NoSig    noExt)   )}
1342         | '::' kind    { sLL $1 $> ([mu AnnDcolon $1], sLL $1 $> (KindSig  noExt $2))}
1343         | '='  tv_bndr { sLL $1 $> ([mj AnnEqual $1] , sLL $1 $> (TyVarSig noExt $2))}
1344
1345 opt_at_kind_inj_sig :: { Located ([AddAnn], ( LFamilyResultSig GhcPs
1346                                             , Maybe (LInjectivityAnn GhcPs)))}
1347         :            { noLoc ([], (noLoc (NoSig noExt), Nothing)) }
1348         | '::' kind  { sLL $1 $> ( [mu AnnDcolon $1]
1349                                  , (sLL $2 $> (KindSig noExt $2), Nothing)) }
1350         | '='  tv_bndr '|' injectivity_cond
1351                 { sLL $1 $> ([mj AnnEqual $1, mj AnnVbar $3]
1352                             , (sLL $1 $2 (TyVarSig noExt $2), Just $4))}
1353
1354 -- tycl_hdr parses the header of a class or data type decl,
1355 -- which takes the form
1356 --      T a b
1357 --      Eq a => T a
1358 --      (Eq a, Ord b) => T a b
1359 --      T Int [a]                       -- for associated types
1360 -- Rather a lot of inlining here, else we get reduce/reduce errors
1361 tycl_hdr :: { Located (Maybe (LHsContext GhcPs), LHsType GhcPs) }
1362         : context '=>' type         {% addAnnotation (gl $1) (toUnicodeAnn AnnDarrow $2) (gl $2)
1363                                        >> (return (sLL $1 $> (Just $1, $3)))
1364                                     }
1365         | type                      { sL1 $1 (Nothing, $1) }
1366
1367 capi_ctype :: { Maybe (Located CType) }
1368 capi_ctype : '{-# CTYPE' STRING STRING '#-}'
1369                        {% ajs (Just (sLL $1 $> (CType (getCTYPEs $1) (Just (Header (getSTRINGs $2) (getSTRING $2)))
1370                                         (getSTRINGs $3,getSTRING $3))))
1371                               [mo $1,mj AnnHeader $2,mj AnnVal $3,mc $4] }
1372
1373            | '{-# CTYPE'        STRING '#-}'
1374                        {% ajs (Just (sLL $1 $> (CType (getCTYPEs $1) Nothing  (getSTRINGs $2, getSTRING $2))))
1375                               [mo $1,mj AnnVal $2,mc $3] }
1376
1377            |           { Nothing }
1378
1379 -----------------------------------------------------------------------------
1380 -- Stand-alone deriving
1381
1382 -- Glasgow extension: stand-alone deriving declarations
1383 stand_alone_deriving :: { LDerivDecl GhcPs }
1384   : 'deriving' deriv_standalone_strategy 'instance' overlap_pragma inst_type
1385                 {% do { let { err = text "in the stand-alone deriving instance"
1386                                     <> colon <+> quotes (ppr $5) }
1387                       ; ams (sLL $1 (hsSigType $>)
1388                                  (DerivDecl noExt (mkHsWildCardBndrs $5) $2 $4))
1389                             [mj AnnDeriving $1, mj AnnInstance $3] } }
1390
1391 -----------------------------------------------------------------------------
1392 -- Role annotations
1393
1394 role_annot :: { LRoleAnnotDecl GhcPs }
1395 role_annot : 'type' 'role' oqtycon maybe_roles
1396           {% amms (mkRoleAnnotDecl (comb3 $1 $3 $4) $3 (reverse (unLoc $4)))
1397                   [mj AnnType $1,mj AnnRole $2] }
1398
1399 -- Reversed!
1400 maybe_roles :: { Located [Located (Maybe FastString)] }
1401 maybe_roles : {- empty -}    { noLoc [] }
1402             | roles          { $1 }
1403
1404 roles :: { Located [Located (Maybe FastString)] }
1405 roles : role             { sLL $1 $> [$1] }
1406       | roles role       { sLL $1 $> $ $2 : unLoc $1 }
1407
1408 -- read it in as a varid for better error messages
1409 role :: { Located (Maybe FastString) }
1410 role : VARID             { sL1 $1 $ Just $ getVARID $1 }
1411      | '_'               { sL1 $1 Nothing }
1412
1413 -- Pattern synonyms
1414
1415 -- Glasgow extension: pattern synonyms
1416 pattern_synonym_decl :: { LHsDecl GhcPs }
1417         : 'pattern' pattern_synonym_lhs '=' pat
1418          {%      let (name, args,as ) = $2 in
1419                  ams (sLL $1 $> . ValD noExt $ mkPatSynBind name args $4
1420                                                     ImplicitBidirectional)
1421                (as ++ [mj AnnPattern $1, mj AnnEqual $3])
1422          }
1423
1424         | 'pattern' pattern_synonym_lhs '<-' pat
1425          {%    let (name, args, as) = $2 in
1426                ams (sLL $1 $> . ValD noExt $ mkPatSynBind name args $4 Unidirectional)
1427                (as ++ [mj AnnPattern $1,mu AnnLarrow $3]) }
1428
1429         | 'pattern' pattern_synonym_lhs '<-' pat where_decls
1430             {% do { let (name, args, as) = $2
1431                   ; mg <- mkPatSynMatchGroup name (snd $ unLoc $5)
1432                   ; ams (sLL $1 $> . ValD noExt $
1433                            mkPatSynBind name args $4 (ExplicitBidirectional mg))
1434                        (as ++ ((mj AnnPattern $1:mu AnnLarrow $3:(fst $ unLoc $5))) )
1435                    }}
1436
1437 pattern_synonym_lhs :: { (Located RdrName, HsPatSynDetails (Located RdrName), [AddAnn]) }
1438         : con vars0 { ($1, PrefixCon $2, []) }
1439         | varid conop varid { ($2, InfixCon $1 $3, []) }
1440         | con '{' cvars1 '}' { ($1, RecCon $3, [moc $2, mcc $4] ) }
1441
1442 vars0 :: { [Located RdrName] }
1443         : {- empty -}                 { [] }
1444         | varid vars0                 { $1 : $2 }
1445
1446 cvars1 :: { [RecordPatSynField (Located RdrName)] }
1447        : var                          { [RecordPatSynField $1 $1] }
1448        | var ',' cvars1               {% addAnnotation (getLoc $1) AnnComma (getLoc $2) >>
1449                                          return ((RecordPatSynField $1 $1) : $3 )}
1450
1451 where_decls :: { Located ([AddAnn]
1452                          , Located (OrdList (LHsDecl GhcPs))) }
1453         : 'where' '{' decls '}'       { sLL $1 $> ((mj AnnWhere $1:moc $2
1454                                            :mcc $4:(fst $ unLoc $3)),sL1 $3 (snd $ unLoc $3)) }
1455         | 'where' vocurly decls close { L (comb2 $1 $3) ((mj AnnWhere $1:(fst $ unLoc $3))
1456                                           ,sL1 $3 (snd $ unLoc $3)) }
1457
1458 pattern_synonym_sig :: { LSig GhcPs }
1459         : 'pattern' con_list '::' sigtypedoc
1460                    {% ams (sLL $1 $> $ PatSynSig noExt (unLoc $2) (mkLHsSigType $4))
1461                           [mj AnnPattern $1, mu AnnDcolon $3] }
1462
1463 -----------------------------------------------------------------------------
1464 -- Nested declarations
1465
1466 -- Declaration in class bodies
1467 --
1468 decl_cls  :: { LHsDecl GhcPs }
1469 decl_cls  : at_decl_cls                 { $1 }
1470           | decl                        { $1 }
1471
1472           -- A 'default' signature used with the generic-programming extension
1473           | 'default' infixexp '::' sigtypedoc
1474                     {% do { v <- checkValSigLhs $2
1475                           ; let err = text "in default signature" <> colon <+>
1476                                       quotes (ppr $2)
1477                           ; ams (sLL $1 $> $ SigD noExt $ ClassOpSig noExt True [v] $ mkLHsSigType $4)
1478                                 [mj AnnDefault $1,mu AnnDcolon $3] } }
1479
1480 decls_cls :: { Located ([AddAnn],OrdList (LHsDecl GhcPs)) }  -- Reversed
1481           : decls_cls ';' decl_cls      {% if isNilOL (snd $ unLoc $1)
1482                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1483                                                                     , unitOL $3))
1484                                              else ams (lastOL (snd $ unLoc $1)) [mj AnnSemi $2]
1485                                            >> return (sLL $1 $> (fst $ unLoc $1
1486                                                                 ,(snd $ unLoc $1) `appOL` unitOL $3)) }
1487           | decls_cls ';'               {% if isNilOL (snd $ unLoc $1)
1488                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1489                                                                                    ,snd $ unLoc $1))
1490                                              else ams (lastOL (snd $ unLoc $1)) [mj AnnSemi $2]
1491                                            >> return (sLL $1 $>  (unLoc $1)) }
1492           | decl_cls                    { sL1 $1 ([], unitOL $1) }
1493           | {- empty -}                 { noLoc ([],nilOL) }
1494
1495 decllist_cls
1496         :: { Located ([AddAnn]
1497                      , OrdList (LHsDecl GhcPs)) }      -- Reversed
1498         : '{'         decls_cls '}'     { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2)
1499                                              ,snd $ unLoc $2) }
1500         |     vocurly decls_cls close   { $2 }
1501
1502 -- Class body
1503 --
1504 where_cls :: { Located ([AddAnn]
1505                        ,(OrdList (LHsDecl GhcPs))) }    -- Reversed
1506                                 -- No implicit parameters
1507                                 -- May have type declarations
1508         : 'where' decllist_cls          { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)
1509                                              ,snd $ unLoc $2) }
1510         | {- empty -}                   { noLoc ([],nilOL) }
1511
1512 -- Declarations in instance bodies
1513 --
1514 decl_inst  :: { Located (OrdList (LHsDecl GhcPs)) }
1515 decl_inst  : at_decl_inst               { sLL $1 $> (unitOL (sL1 $1 (InstD noExt (unLoc $1)))) }
1516            | decl                       { sLL $1 $> (unitOL $1) }
1517
1518 decls_inst :: { Located ([AddAnn],OrdList (LHsDecl GhcPs)) }   -- Reversed
1519            : decls_inst ';' decl_inst   {% if isNilOL (snd $ unLoc $1)
1520                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1521                                                                     , unLoc $3))
1522                                              else ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1523                                            >> return
1524                                             (sLL $1 $> (fst $ unLoc $1
1525                                                        ,(snd $ unLoc $1) `appOL` unLoc $3)) }
1526            | decls_inst ';'             {% if isNilOL (snd $ unLoc $1)
1527                                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1528                                                                                    ,snd $ unLoc $1))
1529                                              else ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1530                                            >> return (sLL $1 $> (unLoc $1)) }
1531            | decl_inst                  { sL1 $1 ([],unLoc $1) }
1532            | {- empty -}                { noLoc ([],nilOL) }
1533
1534 decllist_inst
1535         :: { Located ([AddAnn]
1536                      , OrdList (LHsDecl GhcPs)) }      -- Reversed
1537         : '{'         decls_inst '}'    { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2),snd $ unLoc $2) }
1538         |     vocurly decls_inst close  { L (gl $2) (unLoc $2) }
1539
1540 -- Instance body
1541 --
1542 where_inst :: { Located ([AddAnn]
1543                         , OrdList (LHsDecl GhcPs)) }   -- Reversed
1544                                 -- No implicit parameters
1545                                 -- May have type declarations
1546         : 'where' decllist_inst         { sLL $1 $> (mj AnnWhere $1:(fst $ unLoc $2)
1547                                              ,(snd $ unLoc $2)) }
1548         | {- empty -}                   { noLoc ([],nilOL) }
1549
1550 -- Declarations in binding groups other than classes and instances
1551 --
1552 decls   :: { Located ([AddAnn],OrdList (LHsDecl GhcPs)) }
1553         : decls ';' decl    {% if isNilOL (snd $ unLoc $1)
1554                                  then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
1555                                                         , unitOL $3))
1556                                  else do ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1557                                            >> return (
1558                                           let { this = unitOL $3;
1559                                                 rest = snd $ unLoc $1;
1560                                                 these = rest `appOL` this }
1561                                           in rest `seq` this `seq` these `seq`
1562                                              (sLL $1 $> (fst $ unLoc $1,these))) }
1563         | decls ';'          {% if isNilOL (snd $ unLoc $1)
1564                                   then return (sLL $1 $> ((mj AnnSemi $2:(fst $ unLoc $1)
1565                                                           ,snd $ unLoc $1)))
1566                                   else ams (lastOL $ snd $ unLoc $1) [mj AnnSemi $2]
1567                                            >> return (sLL $1 $> (unLoc $1)) }
1568         | decl                          { sL1 $1 ([], unitOL $1) }
1569         | {- empty -}                   { noLoc ([],nilOL) }
1570
1571 decllist :: { Located ([AddAnn],Located (OrdList (LHsDecl GhcPs))) }
1572         : '{'            decls '}'     { sLL $1 $> (moc $1:mcc $3:(fst $ unLoc $2)
1573                                                    ,sL1 $2 $ snd $ unLoc $2) }
1574         |     vocurly    decls close   { L (gl $2) (fst $ unLoc $2,sL1 $2 $ snd $ unLoc $2) }
1575
1576 -- Binding groups other than those of class and instance declarations
1577 --
1578 binds   ::  { Located ([AddAnn],Located (HsLocalBinds GhcPs)) }
1579                                          -- May have implicit parameters
1580                                                 -- No type declarations
1581         : decllist          {% do { val_binds <- cvBindGroup (unLoc $ snd $ unLoc $1)
1582                                   ; return (sL1 $1 (fst $ unLoc $1
1583                                                     ,sL1 $1 $ HsValBinds noExt val_binds)) } }
1584
1585         | '{'            dbinds '}'     { sLL $1 $> ([moc $1,mcc $3]
1586                                              ,sL1 $2 $ HsIPBinds noExt (IPBinds noExt (reverse $ unLoc $2))) }
1587
1588         |     vocurly    dbinds close   { L (getLoc $2) ([]
1589                                             ,sL1 $2 $ HsIPBinds noExt (IPBinds noExt (reverse $ unLoc $2))) }
1590
1591
1592 wherebinds :: { Located ([AddAnn],Located (HsLocalBinds GhcPs)) }
1593                                                 -- May have implicit parameters
1594                                                 -- No type declarations
1595         : 'where' binds                 { sLL $1 $> (mj AnnWhere $1 : (fst $ unLoc $2)
1596                                              ,snd $ unLoc $2) }
1597         | {- empty -}                   { noLoc ([],noLoc emptyLocalBinds) }
1598
1599
1600 -----------------------------------------------------------------------------
1601 -- Transformation Rules
1602
1603 rules   :: { OrdList (LRuleDecl GhcPs) }
1604         :  rules ';' rule              {% addAnnotation (oll $1) AnnSemi (gl $2)
1605                                           >> return ($1 `snocOL` $3) }
1606         |  rules ';'                   {% addAnnotation (oll $1) AnnSemi (gl $2)
1607                                           >> return $1 }
1608         |  rule                        { unitOL $1 }
1609         |  {- empty -}                 { nilOL }
1610
1611 rule    :: { LRuleDecl GhcPs }
1612         : STRING rule_activation rule_forall infixexp '=' exp
1613          {%ams (sLL $1 $> $ (HsRule noExt (L (gl $1) (getSTRINGs $1,getSTRING $1))
1614                                   ((snd $2) `orElse` AlwaysActive)
1615                                   (snd $3) $4 $6))
1616                (mj AnnEqual $5 : (fst $2) ++ (fst $3)) }
1617
1618 -- Rules can be specified to be NeverActive, unlike inline/specialize pragmas
1619 rule_activation :: { ([AddAnn],Maybe Activation) }
1620         : {- empty -}                           { ([],Nothing) }
1621         | rule_explicit_activation              { (fst $1,Just (snd $1)) }
1622
1623 rule_explicit_activation :: { ([AddAnn]
1624                               ,Activation) }  -- In brackets
1625         : '[' INTEGER ']'       { ([mos $1,mj AnnVal $2,mcs $3]
1626                                   ,ActiveAfter  (getINTEGERs $2) (fromInteger (il_value (getINTEGER $2)))) }
1627         | '[' '~' INTEGER ']'   { ([mos $1,mj AnnTilde $2,mj AnnVal $3,mcs $4]
1628                                   ,ActiveBefore (getINTEGERs $3) (fromInteger (il_value (getINTEGER $3)))) }
1629         | '[' '~' ']'           { ([mos $1,mj AnnTilde $2,mcs $3]
1630                                   ,NeverActive) }
1631
1632 rule_forall :: { ([AddAnn],[LRuleBndr GhcPs]) }
1633         : 'forall' rule_var_list '.'     { ([mu AnnForall $1,mj AnnDot $3],$2) }
1634         | {- empty -}                    { ([],[]) }
1635
1636 rule_var_list :: { [LRuleBndr GhcPs] }
1637         : rule_var                              { [$1] }
1638         | rule_var rule_var_list                { $1 : $2 }
1639
1640 rule_var :: { LRuleBndr GhcPs }
1641         : varid                         { sLL $1 $> (RuleBndr noExt $1) }
1642         | '(' varid '::' ctype ')'      {% ams (sLL $1 $> (RuleBndrSig noExt $2
1643                                                        (mkLHsSigWcType $4)))
1644                                                [mop $1,mu AnnDcolon $3,mcp $5] }
1645
1646 -----------------------------------------------------------------------------
1647 -- Warnings and deprecations (c.f. rules)
1648
1649 warnings :: { OrdList (LWarnDecl GhcPs) }
1650         : warnings ';' warning         {% addAnnotation (oll $1) AnnSemi (gl $2)
1651                                           >> return ($1 `appOL` $3) }
1652         | warnings ';'                 {% addAnnotation (oll $1) AnnSemi (gl $2)
1653                                           >> return $1 }
1654         | warning                      { $1 }
1655         | {- empty -}                  { nilOL }
1656
1657 -- SUP: TEMPORARY HACK, not checking for `module Foo'
1658 warning :: { OrdList (LWarnDecl GhcPs) }
1659         : namelist strings
1660                 {% amsu (sLL $1 $> (Warning noExt (unLoc $1) (WarningTxt (noLoc NoSourceText) $ snd $ unLoc $2)))
1661                      (fst $ unLoc $2) }
1662
1663 deprecations :: { OrdList (LWarnDecl GhcPs) }
1664         : deprecations ';' deprecation
1665                                        {% addAnnotation (oll $1) AnnSemi (gl $2)
1666                                           >> return ($1 `appOL` $3) }
1667         | deprecations ';'             {% addAnnotation (oll $1) AnnSemi (gl $2)
1668                                           >> return $1 }
1669         | deprecation                  { $1 }
1670         | {- empty -}                  { nilOL }
1671
1672 -- SUP: TEMPORARY HACK, not checking for `module Foo'
1673 deprecation :: { OrdList (LWarnDecl GhcPs) }
1674         : namelist strings
1675              {% amsu (sLL $1 $> $ (Warning noExt (unLoc $1) (DeprecatedTxt (noLoc NoSourceText) $ snd $ unLoc $2)))
1676                      (fst $ unLoc $2) }
1677
1678 strings :: { Located ([AddAnn],[Located StringLiteral]) }
1679     : STRING { sL1 $1 ([],[L (gl $1) (getStringLiteral $1)]) }
1680     | '[' stringlist ']' { sLL $1 $> $ ([mos $1,mcs $3],fromOL (unLoc $2)) }
1681
1682 stringlist :: { Located (OrdList (Located StringLiteral)) }
1683     : stringlist ',' STRING {% addAnnotation (oll $ unLoc $1) AnnComma (gl $2) >>
1684                                return (sLL $1 $> (unLoc $1 `snocOL`
1685                                                   (L (gl $3) (getStringLiteral $3)))) }
1686     | STRING                { sLL $1 $> (unitOL (L (gl $1) (getStringLiteral $1))) }
1687     | {- empty -}           { noLoc nilOL }
1688
1689 -----------------------------------------------------------------------------
1690 -- Annotations
1691 annotation :: { LHsDecl GhcPs }
1692     : '{-# ANN' name_var aexp '#-}'      {% ams (sLL $1 $> (AnnD noExt $ HsAnnotation noExt
1693                                             (getANN_PRAGs $1)
1694                                             (ValueAnnProvenance $2) $3))
1695                                             [mo $1,mc $4] }
1696
1697     | '{-# ANN' 'type' tycon aexp '#-}'  {% ams (sLL $1 $> (AnnD noExt $ HsAnnotation noExt
1698                                             (getANN_PRAGs $1)
1699                                             (TypeAnnProvenance $3) $4))
1700                                             [mo $1,mj AnnType $2,mc $5] }
1701
1702     | '{-# ANN' 'module' aexp '#-}'      {% ams (sLL $1 $> (AnnD noExt $ HsAnnotation noExt
1703                                                 (getANN_PRAGs $1)
1704                                                  ModuleAnnProvenance $3))
1705                                                 [mo $1,mj AnnModule $2,mc $4] }
1706
1707
1708 -----------------------------------------------------------------------------
1709 -- Foreign import and export declarations
1710
1711 fdecl :: { Located ([AddAnn],HsDecl GhcPs) }
1712 fdecl : 'import' callconv safety fspec
1713                {% mkImport $2 $3 (snd $ unLoc $4) >>= \i ->
1714                  return (sLL $1 $> (mj AnnImport $1 : (fst $ unLoc $4),i))  }
1715       | 'import' callconv        fspec
1716                {% do { d <- mkImport $2 (noLoc PlaySafe) (snd $ unLoc $3);
1717                     return (sLL $1 $> (mj AnnImport $1 : (fst $ unLoc $3),d)) }}
1718       | 'export' callconv fspec
1719                {% mkExport $2 (snd $ unLoc $3) >>= \i ->
1720                   return (sLL $1 $> (mj AnnExport $1 : (fst $ unLoc $3),i) ) }
1721
1722 callconv :: { Located CCallConv }
1723           : 'stdcall'                   { sLL $1 $> StdCallConv }
1724           | 'ccall'                     { sLL $1 $> CCallConv   }
1725           | 'capi'                      { sLL $1 $> CApiConv    }
1726           | 'prim'                      { sLL $1 $> PrimCallConv}
1727           | 'javascript'                { sLL $1 $> JavaScriptCallConv }
1728
1729 safety :: { Located Safety }
1730         : 'unsafe'                      { sLL $1 $> PlayRisky }
1731         | 'safe'                        { sLL $1 $> PlaySafe }
1732         | 'interruptible'               { sLL $1 $> PlayInterruptible }
1733
1734 fspec :: { Located ([AddAnn]
1735                     ,(Located StringLiteral, Located RdrName, LHsSigType GhcPs)) }
1736        : STRING var '::' sigtypedoc     { sLL $1 $> ([mu AnnDcolon $3]
1737                                              ,(L (getLoc $1)
1738                                                     (getStringLiteral $1), $2, mkLHsSigType $4)) }
1739        |        var '::' sigtypedoc     { sLL $1 $> ([mu AnnDcolon $2]
1740                                              ,(noLoc (StringLiteral NoSourceText nilFS), $1, mkLHsSigType $3)) }
1741          -- if the entity string is missing, it defaults to the empty string;
1742          -- the meaning of an empty entity string depends on the calling
1743          -- convention
1744
1745 -----------------------------------------------------------------------------
1746 -- Type signatures
1747
1748 opt_sig :: { ([AddAnn], Maybe (LHsType GhcPs)) }
1749         : {- empty -}                   { ([],Nothing) }
1750         | '::' sigtype                  { ([mu AnnDcolon $1],Just $2) }
1751
1752 opt_tyconsig :: { ([AddAnn], Maybe (Located RdrName)) }
1753              : {- empty -}              { ([], Nothing) }
1754              | '::' gtycon              { ([mu AnnDcolon $1], Just $2) }
1755
1756 sigtype :: { LHsType GhcPs }
1757         : ctype                            { $1 }
1758
1759 sigtypedoc :: { LHsType GhcPs }
1760         : ctypedoc                         { $1 }
1761
1762
1763 sig_vars :: { Located [Located RdrName] }    -- Returned in reversed order
1764          : sig_vars ',' var           {% addAnnotation (gl $ head $ unLoc $1)
1765                                                        AnnComma (gl $2)
1766                                          >> return (sLL $1 $> ($3 : unLoc $1)) }
1767          | var                        { sL1 $1 [$1] }
1768
1769 sigtypes1 :: { (OrdList (LHsSigType GhcPs)) }
1770    : sigtype                 { unitOL (mkLHsSigType $1) }
1771    | sigtype ',' sigtypes1   {% addAnnotation (gl $1) AnnComma (gl $2)
1772                                 >> return (unitOL (mkLHsSigType $1) `appOL` $3) }
1773
1774 -----------------------------------------------------------------------------
1775 -- Types
1776
1777 strict_mark :: { Located ([AddAnn],HsSrcBang) }
1778         : strictness { sL1 $1 (let (a, str) = unLoc $1 in (a, HsSrcBang NoSourceText NoSrcUnpack str)) }
1779         | unpackedness { sL1 $1 (let (a, prag, unpk) = unLoc $1 in (a, HsSrcBang prag unpk NoSrcStrict)) }
1780         | unpackedness strictness { sLL $1 $> (let { (a, prag, unpk) = unLoc $1
1781                                                    ; (a', str) = unLoc $2 }
1782                                                 in (a ++ a', HsSrcBang prag unpk str)) }
1783         -- Although UNPACK with no '!' without StrictData and UNPACK with '~' are illegal,
1784         -- we get a better error message if we parse them here
1785
1786 strictness :: { Located ([AddAnn], SrcStrictness) }
1787         : '!' { sL1 $1 ([mj AnnBang $1], SrcStrict) }
1788         | '~' { sL1 $1 ([mj AnnTilde $1], SrcLazy) }
1789
1790 unpackedness :: { Located ([AddAnn], SourceText, SrcUnpackedness) }
1791         : '{-# UNPACK' '#-}'   { sLL $1 $> ([mo $1, mc $2], getUNPACK_PRAGs $1, SrcUnpack) }
1792         | '{-# NOUNPACK' '#-}' { sLL $1 $> ([mo $1, mc $2], getNOUNPACK_PRAGs $1, SrcNoUnpack) }
1793
1794 -- A ctype is a for-all type
1795 ctype   :: { LHsType GhcPs }
1796         : 'forall' tv_bndrs '.' ctype   {% hintExplicitForall (getLoc $1) >>
1797                                            ams (sLL $1 $> $
1798                                                 HsForAllTy { hst_bndrs = $2
1799                                                            , hst_xforall = noExt
1800                                                            , hst_body = $4 })
1801                                                [mu AnnForall $1, mj AnnDot $3] }
1802         | context '=>' ctype          {% addAnnotation (gl $1) (toUnicodeAnn AnnDarrow $2) (gl $2)
1803                                          >> return (sLL $1 $> $
1804                                             HsQualTy { hst_ctxt = $1
1805                                                      , hst_xqual = noExt
1806                                                      , hst_body = $3 }) }
1807         | ipvar '::' type             {% ams (sLL $1 $> (HsIParamTy noExt $1 $3))
1808                                              [mu AnnDcolon $2] }
1809         | type                        { $1 }
1810
1811 ----------------------
1812 -- Notes for 'ctypedoc'
1813 -- It would have been nice to simplify the grammar by unifying `ctype` and
1814 -- ctypedoc` into one production, allowing comments on types everywhere (and
1815 -- rejecting them after parsing, where necessary).  This is however not possible
1816 -- since it leads to ambiguity. The reason is the support for comments on record
1817 -- fields:
1818 --         data R = R { field :: Int -- ^ comment on the field }
1819 -- If we allow comments on types here, it's not clear if the comment applies
1820 -- to 'field' or to 'Int'. So we must use `ctype` to describe the type.
1821
1822 ctypedoc :: { LHsType GhcPs }
1823         : 'forall' tv_bndrs '.' ctypedoc {% hintExplicitForall (getLoc $1) >>
1824                                             ams (sLL $1 $> $
1825                                                  HsForAllTy { hst_bndrs = $2
1826                                                             , hst_xforall = noExt
1827                                                             , hst_body = $4 })
1828                                                 [mu AnnForall $1,mj AnnDot $3] }
1829         | context '=>' ctypedoc       {% addAnnotation (gl $1) (toUnicodeAnn AnnDarrow $2) (gl $2)
1830                                          >> return (sLL $1 $> $
1831                                             HsQualTy { hst_ctxt = $1
1832                                                      , hst_xqual = noExt
1833                                                      , hst_body = $3 }) }
1834         | ipvar '::' type             {% ams (sLL $1 $> (HsIParamTy noExt $1 $3))
1835                                              [mu AnnDcolon $2] }
1836         | typedoc                     { $1 }
1837
1838 ----------------------
1839 -- Notes for 'context'
1840 -- We parse a context as a btype so that we don't get reduce/reduce
1841 -- errors in ctype.  The basic problem is that
1842 --      (Eq a, Ord a)
1843 -- looks so much like a tuple type.  We can't tell until we find the =>
1844
1845 -- We have the t1 ~ t2 form both in 'context' and in type,
1846 -- to permit an individual equational constraint without parenthesis.
1847 -- Thus for some reason we allow    f :: a~b => blah
1848 -- but not                          f :: ?x::Int => blah
1849 -- See Note [Parsing ~]
1850 context :: { LHsContext GhcPs }
1851         :  btype                        {% do { (anns,ctx) <- checkContext $1
1852                                                 ; if null (unLoc ctx)
1853                                                    then addAnnotation (gl $1) AnnUnit (gl $1)
1854                                                    else return ()
1855                                                 ; ams ctx anns
1856                                                 } }
1857
1858 context_no_ops :: { LHsContext GhcPs }
1859         : btype_no_ops                 {% do { ty <- splitTilde $1
1860                                              ; (anns,ctx) <- checkContext ty
1861                                              ; if null (unLoc ctx)
1862                                                    then addAnnotation (gl ty) AnnUnit (gl ty)
1863                                                    else return ()
1864                                              ; ams ctx anns
1865                                              } }
1866
1867 {- Note [GADT decl discards annotations]
1868 ~~~~~~~~~~~~~~~~~~~~~
1869 The type production for
1870
1871     btype `->`         ctypedoc
1872     btype docprev `->` ctypedoc
1873
1874 add the AnnRarrow annotation twice, in different places.
1875
1876 This is because if the type is processed as usual, it belongs on the annotations
1877 for the type as a whole.
1878
1879 But if the type is passed to mkGadtDecl, it discards the top level SrcSpan, and
1880 the top-level annotation will be disconnected. Hence for this specific case it
1881 is connected to the first type too.
1882 -}
1883
1884 type :: { LHsType GhcPs }
1885         : btype                        { $1 }
1886         | btype '->' ctype             {% 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                      {%  splitTildeApps (reverse (unLoc $1)) >>=
1915                                           \ts -> return $ sL1 $1 $ mkHsAppsTy ts }
1916
1917 -- Used for parsing Haskell98-style data constructors,
1918 -- in order to forbid the blasphemous
1919 -- > data Foo = Int :+ Char :* Bool
1920 -- See also Note [Parsing data constructors is hard] in RdrHsSyn
1921 btype_no_ops :: { LHsType GhcPs }
1922         : btype_no_ops atype_docs       { sLL $1 $> $ HsAppTy noExt $1 $2 }
1923         | atype_docs                    { $1 }
1924
1925 tyapps :: { Located [LHsAppType GhcPs] }   -- NB: This list is reversed
1926         : tyapp                         { sL1 $1 [$1] }
1927         | tyapps tyapp                  { sLL $1 $> $ $2 : (unLoc $1) }
1928
1929 -- See Note [HsAppsTy] in HsTypes
1930 tyapp :: { LHsAppType GhcPs }
1931         : atype                         { sL1 $1 $ HsAppPrefix noExt $1 }
1932         | qtyconop                      { sL1 $1 $ HsAppInfix noExt $1 }
1933         | tyvarop                       { sL1 $1 $ HsAppInfix noExt $1 }
1934         | SIMPLEQUOTE qconop            {% ams (sLL $1 $> $ HsAppInfix noExt $2)
1935                                                [mj AnnSimpleQuote $1] }
1936         | SIMPLEQUOTE varop             {% ams (sLL $1 $> $ HsAppInfix noExt $2)
1937                                                [mj AnnSimpleQuote $1] }
1938
1939 atype_docs :: { LHsType GhcPs }
1940         : atype docprev                 { sLL $1 $> $ HsDocTy noExt $1 $2 }
1941         | atype                         { $1 }
1942
1943 atype :: { LHsType GhcPs }
1944         : ntgtycon                       { sL1 $1 (HsTyVar noExt NotPromoted $1) }      -- Not including unit tuples
1945         | tyvar                          { sL1 $1 (HsTyVar noExt NotPromoted $1) }      -- (See Note [Unit tuples])
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 HsEqTy'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 HsEqTy'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                 {% ams (sLL $1 $> (mkGadtDecl (unLoc $1) $3))
2146                        [mu AnnDcolon $2] }
2147
2148 {- Note [Difference in parsing GADT and data constructors]
2149 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2150 GADT constructors have simpler syntax than usual data constructors:
2151 in GADTs, types cannot occur to the left of '::', so they cannot be mixed
2152 with constructor names (see Note [Parsing data constructors is hard]).
2153
2154 Due to simplified syntax, GADT constructor names (left-hand side of '::')
2155 use simpler grammar production than usual data constructor names. As a
2156 consequence, GADT constructor names are resticted (names like '(*)' are
2157 allowed in usual data constructors, but not in GADTs).
2158 -}
2159
2160 constrs :: { Located ([AddAnn],[LConDecl GhcPs]) }
2161         : maybe_docnext '=' constrs1    { L (comb2 $2 $3) ([mj AnnEqual $2]
2162                                                      ,addConDocs (unLoc $3) $1)}
2163
2164 constrs1 :: { Located [LConDecl GhcPs] }
2165         : constrs1 maybe_docnext '|' maybe_docprev constr
2166             {% addAnnotation (gl $ head $ unLoc $1) AnnVbar (gl $3)
2167                >> return (sLL $1 $> (addConDoc $5 $2 : addConDocFirst (unLoc $1) $4)) }
2168         | constr                                          { sL1 $1 [$1] }
2169
2170 constr :: { LConDecl GhcPs }
2171         : maybe_docnext forall context_no_ops '=>' constr_stuff
2172                 {% ams (let (con,details,doc_prev) = unLoc $5 in
2173                   addConDoc (L (comb4 $2 $3 $4 $5) (mkConDeclH98 con
2174                                                        (snd $ unLoc $2)
2175                                                        (Just $3)
2176                                                        details))
2177                             ($1 `mplus` doc_prev))
2178                         (mu AnnDarrow $4:(fst $ unLoc $2)) }
2179         | maybe_docnext forall constr_stuff
2180                 {% ams ( let (con,details,doc_prev) = unLoc $3 in
2181                   addConDoc (L (comb2 $2 $3) (mkConDeclH98 con
2182                                                       (snd $ unLoc $2)
2183                                                       Nothing   -- No context
2184                                                       details))
2185                             ($1 `mplus` doc_prev))
2186                        (fst $ unLoc $2) }
2187
2188 forall :: { Located ([AddAnn], Maybe [LHsTyVarBndr GhcPs]) }
2189         : 'forall' tv_bndrs '.'       { sLL $1 $> ([mu AnnForall $1,mj AnnDot $3], Just $2) }
2190         | {- empty -}                 { noLoc ([], Nothing) }
2191
2192 constr_stuff :: { Located (Located RdrName, HsConDeclDetails GhcPs, Maybe LHsDocString) }
2193     -- See Note [Parsing data constructors is hard] in RdrHsSyn
2194         : btype_no_ops                         {% do { c <- splitCon $1
2195                                                      ; return $ sLL $1 $> c } }
2196         | btype_no_ops conop maybe_docprev btype_no_ops
2197             {% do { lhs <- splitTilde $1
2198                               ; (_, ds_l) <- checkInfixConstr lhs
2199                   ; (rhs, ds_r) <- checkInfixConstr $4
2200                   ; return $ if isJust (ds_l `mplus` $3)
2201                                then sLL $1 $> ($2, InfixCon lhs $4, $3)
2202                                else sLL $1 $> ($2, InfixCon lhs rhs, ds_r) } }
2203
2204 fielddecls :: { [LConDeclField GhcPs] }
2205         : {- empty -}     { [] }
2206         | fielddecls1     { $1 }
2207
2208 fielddecls1 :: { [LConDeclField GhcPs] }
2209         : fielddecl maybe_docnext ',' maybe_docprev fielddecls1
2210             {% addAnnotation (gl $1) AnnComma (gl $3) >>
2211                return ((addFieldDoc $1 $4) : addFieldDocs $5 $2) }
2212         | fielddecl   { [$1] }
2213
2214 fielddecl :: { LConDeclField GhcPs }
2215                                               -- A list because of   f,g :: Int
2216         : maybe_docnext sig_vars '::' ctype maybe_docprev
2217             {% ams (L (comb2 $2 $4)
2218                       (ConDeclField noExt (reverse (map (\ln@(L l n) -> L l $ FieldOcc noExt ln) (unLoc $2))) $4 ($1 `mplus` $5)))
2219                    [mu AnnDcolon $3] }
2220
2221 -- Reversed!
2222 maybe_derivings :: { HsDeriving GhcPs }
2223         : {- empty -}             { noLoc [] }
2224         | derivings               { $1 }
2225
2226 -- A list of one or more deriving clauses at the end of a datatype
2227 derivings :: { HsDeriving GhcPs }
2228         : derivings deriving      { sLL $1 $> $ $2 : unLoc $1 }
2229         | deriving                { sLL $1 $> [$1] }
2230
2231 -- The outer Located is just to allow the caller to
2232 -- know the rightmost extremity of the 'deriving' clause
2233 deriving :: { LHsDerivingClause GhcPs }
2234         : 'deriving' deriv_clause_types
2235               {% let { full_loc = comb2 $1 $> }
2236                  in ams (L full_loc $ HsDerivingClause noExt Nothing $2)
2237                         [mj AnnDeriving $1] }
2238
2239         | 'deriving' deriv_strategy_no_via deriv_clause_types
2240               {% let { full_loc = comb2 $1 $> }
2241                  in ams (L full_loc $ HsDerivingClause noExt (Just $2) $3)
2242                         [mj AnnDeriving $1] }
2243
2244         | 'deriving' deriv_clause_types deriv_strategy_via
2245               {% let { full_loc = comb2 $1 $> }
2246                  in ams (L full_loc $ HsDerivingClause noExt (Just $3) $2)
2247                         [mj AnnDeriving $1] }
2248
2249 deriv_clause_types :: { Located [LHsSigType GhcPs] }
2250         : qtycondoc           { sL1 $1 [mkLHsSigType $1] }
2251         | '(' ')'             {% ams (sLL $1 $> [])
2252                                      [mop $1,mcp $2] }
2253         | '(' deriv_types ')' {% ams (sLL $1 $> $2)
2254                                      [mop $1,mcp $3] }
2255              -- Glasgow extension: allow partial
2256              -- applications in derivings
2257
2258 -----------------------------------------------------------------------------
2259 -- Value definitions
2260
2261 {- Note [Declaration/signature overlap]
2262 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2263 There's an awkward overlap with a type signature.  Consider
2264         f :: Int -> Int = ...rhs...
2265    Then we can't tell whether it's a type signature or a value
2266    definition with a result signature until we see the '='.
2267    So we have to inline enough to postpone reductions until we know.
2268 -}
2269
2270 {-
2271   ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var
2272   instead of qvar, we get another shift/reduce-conflict. Consider the
2273   following programs:
2274
2275      { (^^) :: Int->Int ; }          Type signature; only var allowed
2276
2277      { (^^) :: Int->Int = ... ; }    Value defn with result signature;
2278                                      qvar allowed (because of instance decls)
2279
2280   We can't tell whether to reduce var to qvar until after we've read the signatures.
2281 -}
2282
2283 docdecl :: { LHsDecl GhcPs }
2284         : docdecld { sL1 $1 (DocD noExt (unLoc $1)) }
2285
2286 docdecld :: { LDocDecl }
2287         : docnext                               { sL1 $1 (DocCommentNext (unLoc $1)) }
2288         | docprev                               { sL1 $1 (DocCommentPrev (unLoc $1)) }
2289         | docnamed                              { sL1 $1 (case (unLoc $1) of (n, doc) -> DocCommentNamed n doc) }
2290         | docsection                            { sL1 $1 (case (unLoc $1) of (n, doc) -> DocGroup n doc) }
2291
2292 decl_no_th :: { LHsDecl GhcPs }
2293         : sigdecl               { $1 }
2294
2295         | '!' aexp rhs          {% do { let { e = sLL $1 $2 (SectionR noExt (sL1 $1 (HsVar noExt (sL1 $1 bang_RDR))) $2)
2296                                             ; l = comb2 $1 $> };
2297                                         (ann, r) <- checkValDef empty SrcStrict e Nothing $3 ;
2298                                         hintBangPat (comb2 $1 $2) (unLoc e) ;
2299                                         -- Depending upon what the pattern looks like we might get either
2300                                         -- a FunBind or PatBind back from checkValDef. See Note
2301                                         -- [FunBind vs PatBind]
2302                                         case r of {
2303                                           (FunBind _ n _ _ _) ->
2304                                                 ams (L l ()) [mj AnnFunId n] >> return () ;
2305                                           (PatBind _ (L lh _lhs) _rhs _) ->
2306                                                 ams (L lh ()) [] >> return () } ;
2307
2308                                         _ <- ams (L l ()) (ann ++ fst (unLoc $3) ++ [mj AnnBang $1]) ;
2309                                         return $! (sL l $ ValD noExt r) } }
2310
2311         | infixexp_top opt_sig rhs  {% do { (ann,r) <- checkValDef empty NoSrcStrict $1 (snd $2) $3;
2312                                         let { l = comb2 $1 $> };
2313                                         -- Depending upon what the pattern looks like we might get either
2314                                         -- a FunBind or PatBind back from checkValDef. See Note
2315                                         -- [FunBind vs PatBind]
2316                                         case r of {
2317                                           (FunBind _ n _ _ _) ->
2318                                                 ams (L l ()) (mj AnnFunId n:(fst $2)) >> return () ;
2319                                           (PatBind _ (L lh _lhs) _rhs _) ->
2320                                                 ams (L lh ()) (fst $2) >> return () } ;
2321                                         _ <- ams (L l ()) (ann ++ (fst $ unLoc $3));
2322                                         return $! (sL l $ ValD noExt r) } }
2323         | pattern_synonym_decl  { $1 }
2324         | docdecl               { $1 }
2325
2326 decl    :: { LHsDecl GhcPs }
2327         : decl_no_th            { $1 }
2328
2329         -- Why do we only allow naked declaration splices in top-level
2330         -- declarations and not here? Short answer: because readFail009
2331         -- fails terribly with a panic in cvBindsAndSigs otherwise.
2332         | splice_exp            { sLL $1 $> $ mkSpliceDecl $1 }
2333
2334 rhs     :: { Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)) }
2335         : '=' exp wherebinds    { sL (comb3 $1 $2 $3)
2336                                     ((mj AnnEqual $1 : (fst $ unLoc $3))
2337                                     ,GRHSs noExt (unguardedRHS (comb3 $1 $2 $3) $2)
2338                                    (snd $ unLoc $3)) }
2339         | gdrhs wherebinds      { sLL $1 $>  (fst $ unLoc $2
2340                                     ,GRHSs noExt (reverse (unLoc $1))
2341                                                     (snd $ unLoc $2)) }
2342
2343 gdrhs :: { Located [LGRHS GhcPs (LHsExpr GhcPs)] }
2344         : gdrhs gdrh            { sLL $1 $> ($2 : unLoc $1) }
2345         | gdrh                  { sL1 $1 [$1] }
2346
2347 gdrh :: { LGRHS GhcPs (LHsExpr GhcPs) }
2348         : '|' guardquals '=' exp  {% ams (sL (comb2 $1 $>) $ GRHS noExt (unLoc $2) $4)
2349                                          [mj AnnVbar $1,mj AnnEqual $3] }
2350
2351 sigdecl :: { LHsDecl GhcPs }
2352         :
2353         -- See Note [Declaration/signature overlap] for why we need infixexp here
2354           infixexp_top '::' sigtypedoc
2355                         {% do v <- checkValSigLhs $1
2356                         ; _ <- ams (sLL $1 $> ()) [mu AnnDcolon $2]
2357                         ; return (sLL $1 $> $ SigD noExt $
2358                                   TypeSig noExt [v] (mkLHsSigWcType $3)) }
2359
2360         | var ',' sig_vars '::' sigtypedoc
2361            {% do { let sig = TypeSig noExt ($1 : reverse (unLoc $3))
2362                                      (mkLHsSigWcType $5)
2363                  ; addAnnotation (gl $1) AnnComma (gl $2)
2364                  ; ams ( sLL $1 $> $ SigD noExt sig )
2365                        [mu AnnDcolon $4] } }
2366
2367         | infix prec ops
2368               {% ams (sLL $1 $> $ SigD noExt
2369                         (FixSig noExt (FixitySig noExt (fromOL $ unLoc $3)
2370                                 (Fixity (fst $ unLoc $2) (snd $ unLoc $2) (unLoc $1)))))
2371                      [mj AnnInfix $1,mj AnnVal $2] }
2372
2373         | pattern_synonym_sig   { sLL $1 $> . SigD noExt . unLoc $ $1 }
2374
2375         | '{-# COMPLETE' con_list opt_tyconsig  '#-}'
2376                 {% let (dcolon, tc) = $3
2377                    in ams
2378                        (sLL $1 $>
2379                          (SigD noExt (CompleteMatchSig noExt (getCOMPLETE_PRAGs $1) $2 tc)))
2380                     ([ mo $1 ] ++ dcolon ++ [mc $4]) }
2381
2382         -- This rule is for both INLINE and INLINABLE pragmas
2383         | '{-# INLINE' activation qvar '#-}'
2384                 {% ams ((sLL $1 $> $ SigD noExt (InlineSig noExt $3
2385                             (mkInlinePragma (getINLINE_PRAGs $1) (getINLINE $1)
2386                                             (snd $2)))))
2387                        ((mo $1:fst $2) ++ [mc $4]) }
2388
2389         | '{-# SCC' qvar '#-}'
2390           {% ams (sLL $1 $> (SigD noExt (SCCFunSig noExt (getSCC_PRAGs $1) $2 Nothing)))
2391                  [mo $1, mc $3] }
2392
2393         | '{-# SCC' qvar STRING '#-}'
2394           {% do { scc <- getSCC $3
2395                 ; let str_lit = StringLiteral (getSTRINGs $3) scc
2396                 ; ams (sLL $1 $> (SigD noExt (SCCFunSig noExt (getSCC_PRAGs $1) $2 (Just ( sL1 $3 str_lit)))))
2397                       [mo $1, mc $4] } }
2398
2399         | '{-# SPECIALISE' activation qvar '::' sigtypes1 '#-}'
2400              {% ams (
2401                  let inl_prag = mkInlinePragma (getSPEC_PRAGs $1)
2402                                              (NoUserInline, FunLike) (snd $2)
2403                   in sLL $1 $> $ SigD noExt (SpecSig noExt $3 (fromOL $5) inl_prag))
2404                     (mo $1:mu AnnDcolon $4:mc $6:(fst $2)) }
2405
2406         | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes1 '#-}'
2407              {% ams (sLL $1 $> $ SigD noExt (SpecSig noExt $3 (fromOL $5)
2408                                (mkInlinePragma (getSPEC_INLINE_PRAGs $1)
2409                                                (getSPEC_INLINE $1) (snd $2))))
2410                        (mo $1:mu AnnDcolon $4:mc $6:(fst $2)) }
2411
2412         | '{-# SPECIALISE' 'instance' inst_type '#-}'
2413                 {% ams (sLL $1 $>
2414                                   $ SigD noExt (SpecInstSig noExt (getSPEC_PRAGs $1) $3))
2415                        [mo $1,mj AnnInstance $2,mc $4] }
2416
2417         -- A minimal complete definition
2418         | '{-# MINIMAL' name_boolformula_opt '#-}'
2419             {% ams (sLL $1 $> $ SigD noExt (MinimalSig noExt (getMINIMAL_PRAGs $1) $2))
2420                    [mo $1,mc $3] }
2421
2422 activation :: { ([AddAnn],Maybe Activation) }
2423         : {- empty -}                           { ([],Nothing) }
2424         | explicit_activation                   { (fst $1,Just (snd $1)) }
2425
2426 explicit_activation :: { ([AddAnn],Activation) }  -- In brackets
2427         : '[' INTEGER ']'       { ([mj AnnOpenS $1,mj AnnVal $2,mj AnnCloseS $3]
2428                                   ,ActiveAfter  (getINTEGERs $2) (fromInteger (il_value (getINTEGER $2)))) }
2429         | '[' '~' INTEGER ']'   { ([mj AnnOpenS $1,mj AnnTilde $2,mj AnnVal $3
2430                                                  ,mj AnnCloseS $4]
2431                                   ,ActiveBefore (getINTEGERs $3) (fromInteger (il_value (getINTEGER $3)))) }
2432
2433 -----------------------------------------------------------------------------
2434 -- Expressions
2435
2436 quasiquote :: { Located (HsSplice GhcPs) }
2437         : TH_QUASIQUOTE   { let { loc = getLoc $1
2438                                 ; ITquasiQuote (quoter, quote, quoteSpan) = unLoc $1
2439                                 ; quoterId = mkUnqual varName quoter }
2440                             in sL1 $1 (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote) }
2441         | TH_QQUASIQUOTE  { let { loc = getLoc $1
2442                                 ; ITqQuasiQuote (qual, quoter, quote, quoteSpan) = unLoc $1
2443                                 ; quoterId = mkQual varName (qual, quoter) }
2444                             in sL (getLoc $1) (mkHsQuasiQuote quoterId (RealSrcSpan quoteSpan) quote) }
2445
2446 exp   :: { LHsExpr GhcPs }
2447         : infixexp '::' sigtype {% ams (sLL $1 $> $ ExprWithTySig (mkLHsSigWcType $3) $1)
2448                                        [mu AnnDcolon $2] }
2449         | infixexp '-<' exp     {% ams (sLL $1 $> $ HsArrApp noExt $1 $3
2450                                                         HsFirstOrderApp True)
2451                                        [mu Annlarrowtail $2] }
2452         | infixexp '>-' exp     {% ams (sLL $1 $> $ HsArrApp noExt $3 $1
2453                                                       HsFirstOrderApp False)
2454                                        [mu Annrarrowtail $2] }
2455         | infixexp '-<<' exp    {% ams (sLL $1 $> $ HsArrApp noExt $1 $3
2456                                                       HsHigherOrderApp True)
2457                                        [mu AnnLarrowtail $2] }
2458         | infixexp '>>-' exp    {% ams (sLL $1 $> $ HsArrApp noExt $3 $1
2459                                                       HsHigherOrderApp False)
2460                                        [mu AnnRarrowtail $2] }
2461         | infixexp              { $1 }
2462
2463 infixexp :: { LHsExpr GhcPs }
2464         : exp10 { $1 }
2465         | infixexp qop exp10  {% ams (sLL $1 $> (OpApp noExt $1 $2 $3))
2466                                      [mj AnnVal $2] }
2467                  -- AnnVal annotation for NPlusKPat, which discards the operator
2468
2469 infixexp_top :: { LHsExpr GhcPs }
2470         : exp10_top               { $1 }
2471         | infixexp_top qop exp10_top
2472                                   {% ams (sLL $1 $> (OpApp noExt $1 $2 $3))
2473                                          [mj AnnVal $2] }
2474
2475
2476 exp10_top :: { LHsExpr GhcPs }
2477         : '-' fexp                      {% ams (sLL $1 $> $ NegApp noExt $2 noSyntaxExpr)
2478                                                [mj AnnMinus $1] }
2479
2480
2481         | hpc_annot exp        {% ams (sLL $1 $> $ HsTickPragma noExt (snd $ fst $ fst $ unLoc $1)
2482                                                                 (snd $ fst $ unLoc $1) (snd $ unLoc $1) $2)
2483                                       (fst $ fst $ fst $ unLoc $1) }
2484
2485         | '{-# CORE' STRING '#-}' exp  {% ams (sLL $1 $> $ HsCoreAnn noExt (getCORE_PRAGs $1) (getStringLiteral $2) $4)
2486                                               [mo $1,mj AnnVal $2
2487                                               ,mc $3] }
2488                                           -- hdaume: core annotation
2489         | fexp                         { $1 }
2490
2491 exp10 :: { LHsExpr GhcPs }
2492         : exp10_top            { $1 }
2493         | scc_annot exp        {% ams (sLL $1 $> $ HsSCC noExt (snd $ fst $ unLoc $1) (snd $ unLoc $1) $2)
2494                                       (fst $ fst $ unLoc $1) }
2495
2496 optSemi :: { ([Located a],Bool) }
2497         : ';'         { ([$1],True) }
2498         | {- empty -} { ([],False) }
2499
2500 scc_annot :: { Located (([AddAnn],SourceText),StringLiteral) }
2501         : '{-# SCC' STRING '#-}'      {% do scc <- getSCC $2
2502                                             ; return $ sLL $1 $>
2503                                                (([mo $1,mj AnnValStr $2
2504                                                 ,mc $3],getSCC_PRAGs $1),(StringLiteral (getSTRINGs $2) scc)) }
2505         | '{-# SCC' VARID  '#-}'      { sLL $1 $> (([mo $1,mj AnnVal $2
2506                                          ,mc $3],getSCC_PRAGs $1)
2507                                         ,(StringLiteral NoSourceText (getVARID $2))) }
2508
2509 hpc_annot :: { Located ( (([AddAnn],SourceText),(StringLiteral,(Int,Int),(Int,Int))),
2510                          ((SourceText,SourceText),(SourceText,SourceText))
2511                        ) }
2512       : '{-# GENERATED' STRING INTEGER ':' INTEGER '-' INTEGER ':' INTEGER '#-}'
2513                                       { sLL $1 $> $ ((([mo $1,mj AnnVal $2
2514                                               ,mj AnnVal $3,mj AnnColon $4
2515                                               ,mj AnnVal $5,mj AnnMinus $6
2516                                               ,mj AnnVal $7,mj AnnColon $8
2517                                               ,mj AnnVal $9,mc $10],
2518                                                 getGENERATED_PRAGs $1)
2519                                               ,((getStringLiteral $2)
2520                                                ,( fromInteger $ il_value $ getINTEGER $3
2521                                                 , fromInteger $ il_value $ getINTEGER $5
2522                                                 )
2523                                                ,( fromInteger $ il_value $ getINTEGER $7
2524                                                 , fromInteger $ il_value $ getINTEGER $9
2525                                                 )
2526                                                ))
2527                                              , (( getINTEGERs $3
2528                                                 , getINTEGERs $5
2529                                                 )
2530                                                ,( getINTEGERs $7
2531                                                 , getINTEGERs $9
2532                                                 )))
2533                                          }
2534
2535 fexp    :: { LHsExpr GhcPs }
2536         : fexp aexp                  {% checkBlockArguments $1 >> checkBlockArguments $2 >>
2537                                         return (sLL $1 $> $ (HsApp noExt $1 $2)) }
2538         | fexp TYPEAPP atype         {% checkBlockArguments $1 >>
2539                                         ams (sLL $1 $> $ HsAppType (mkHsWildCardBndrs $3) $1)
2540                                             [mj AnnAt $2] }
2541         | 'static' aexp              {% ams (sLL $1 $> $ HsStatic noExt $2)
2542                                             [mj AnnStatic $1] }
2543         | aexp                       { $1 }
2544
2545 aexp    :: { LHsExpr GhcPs }
2546         : qvar '@' aexp         {% ams (sLL $1 $> $ EAsPat noExt $1 $3) [mj AnnAt $2] }
2547             -- If you change the parsing, make sure to understand
2548             -- Note [Lexing type applications] in Lexer.x
2549
2550         | '~' aexp              {% ams (sLL $1 $> $ ELazyPat noExt $2) [mj AnnTilde $1] }
2551
2552         | '\\' apat apats '->' exp
2553                    {% ams (sLL $1 $> $ HsLam noExt (mkMatchGroup FromSource
2554                             [sLL $1 $> $ Match { m_ext = noExt
2555                                                , m_ctxt = LambdaExpr
2556                                                , m_pats = $2:$3
2557                                                , m_grhss = unguardedGRHSs $5 }]))
2558                           [mj AnnLam $1, mu AnnRarrow $4] }
2559         | 'let' binds 'in' exp          {% ams (sLL $1 $> $ HsLet noExt (snd $ unLoc $2) $4)
2560                                                (mj AnnLet $1:mj AnnIn $3
2561                                                  :(fst $ unLoc $2)) }
2562         | '\\' 'lcase' altslist
2563             {% ams (sLL $1 $> $ HsLamCase noExt
2564                                    (mkMatchGroup FromSource (snd $ unLoc $3)))
2565                    (mj AnnLam $1:mj AnnCase $2:(fst $ unLoc $3)) }
2566         | 'if' exp optSemi 'then' exp optSemi 'else' exp
2567                            {% checkDoAndIfThenElse $2 (snd $3) $5 (snd $6) $8 >>
2568                               ams (sLL $1 $> $ mkHsIf $2 $5 $8)
2569                                   (mj AnnIf $1:mj AnnThen $4
2570                                      :mj AnnElse $7
2571                                      :(map (\l -> mj AnnSemi l) (fst $3))
2572                                     ++(map (\l -> mj AnnSemi l) (fst $6))) }
2573         | 'if' ifgdpats                 {% hintMultiWayIf (getLoc $1) >>
2574                                            ams (sLL $1 $> $ HsMultiIf noExt
2575                                                      (reverse $ snd $ unLoc $2))
2576                                                (mj AnnIf $1:(fst $ unLoc $2)) }
2577         | 'case' exp 'of' altslist      {% ams (L (comb3 $1 $3 $4) $
2578                                                    HsCase noExt $2 (mkMatchGroup
2579                                                    FromSource (snd $ unLoc $4)))
2580                                                (mj AnnCase $1:mj AnnOf $3
2581                                                   :(fst $ unLoc $4)) }
2582         | 'do' stmtlist              {% ams (L (comb2 $1 $2)
2583                                                (mkHsDo DoExpr (snd $ unLoc $2)))
2584                                                (mj AnnDo $1:(fst $ unLoc $2)) }
2585         | 'mdo' stmtlist            {% ams (L (comb2 $1 $2)
2586                                               (mkHsDo MDoExpr (snd $ unLoc $2)))
2587                                            (mj AnnMdo $1:(fst $ unLoc $2)) }
2588         | 'proc' aexp '->' exp
2589                        {% checkPattern empty $2 >>= \ p ->
2590                            checkCommand $4 >>= \ cmd ->
2591                            ams (sLL $1 $> $ HsProc noExt p (sLL $1 $> $ HsCmdTop noExt cmd))
2592                                             -- TODO: is LL right here?
2593                                [mj AnnProc $1,mu AnnRarrow $3] }
2594
2595         | aexp1                 { $1 }
2596
2597 aexp1   :: { LHsExpr GhcPs }
2598         : aexp1 '{' fbinds '}' {% do { r <- mkRecConstrOrUpdate $1 (comb2 $2 $4)
2599                                                                    (snd $3)
2600                                      ; _ <- ams (sLL $1 $> ()) (moc $2:mcc $4:(fst $3))
2601                                      ; checkRecordSyntax (sLL $1 $> r) }}
2602         | aexp2                { $1 }
2603
2604 aexp2   :: { LHsExpr GhcPs }
2605         : qvar                          { sL1 $1 (HsVar noExt   $! $1) }
2606         | qcon                          { sL1 $1 (HsVar noExt   $! $1) }
2607         | ipvar                         { sL1 $1 (HsIPVar noExt $! unLoc $1) }
2608         | overloaded_label              { sL1 $1 (HsOverLabel noExt Nothing $! unLoc $1) }
2609         | literal                       { sL1 $1 (HsLit noExt  $! unLoc $1) }
2610 -- This will enable overloaded strings permanently.  Normally the renamer turns HsString
2611 -- into HsOverLit when -foverloaded-strings is on.
2612 --      | STRING    { sL (getLoc $1) (HsOverLit $! mkHsIsString (getSTRINGs $1)
2613 --                                       (getSTRING $1) noExt) }
2614         | INTEGER   { sL (getLoc $1) (HsOverLit noExt $! mkHsIntegral   (getINTEGER $1) ) }
2615         | RATIONAL  { sL (getLoc $1) (HsOverLit noExt $! mkHsFractional (getRATIONAL $1) ) }
2616
2617         -- N.B.: sections get parsed by these next two productions.
2618         -- This allows you to write, e.g., '(+ 3, 4 -)', which isn't
2619         -- correct Haskell (you'd have to write '((+ 3), (4 -))')
2620         -- but the less cluttered version fell out of having texps.
2621         | '(' texp ')'                  {% ams (sLL $1 $> (HsPar noExt $2)) [mop $1,mcp $3] }
2622         | '(' tup_exprs ')'             {% do { e <- mkSumOrTuple Boxed (comb2 $1 $3) (snd $2)
2623                                               ; ams (sLL $1 $> e) ((mop $1:fst $2) ++ [mcp $3]) } }
2624
2625         | '(#' texp '#)'                {% ams (sLL $1 $> (ExplicitTuple noExt [L (gl $2)
2626                                                          (Present noExt $2)] Unboxed))
2627                                                [mo $1,mc $3] }
2628         | '(#' tup_exprs '#)'           {% do { e <- mkSumOrTuple Unboxed (comb2 $1 $3) (snd $2)
2629                                               ; ams (sLL $1 $> e) ((mo $1:fst $2) ++ [mc $3]) } }
2630
2631         | '[' list ']'      {% ams (sLL $1 $> (snd $2)) (mos $1:mcs $3:(fst $2)) }
2632         | '_'               { sL1 $1 $ EWildPat noExt }
2633
2634         -- Template Haskell Extension
2635         | splice_exp            { $1 }
2636
2637         | SIMPLEQUOTE  qvar     {% ams (sLL $1 $> $ HsBracket noExt (VarBr noExt True  (unLoc $2))) [mj AnnSimpleQuote $1,mj AnnName $2] }
2638         | SIMPLEQUOTE  qcon     {% ams (sLL $1 $> $ HsBracket noExt (VarBr noExt True  (unLoc $2))) [mj AnnSimpleQuote $1,mj AnnName $2] }
2639         | TH_TY_QUOTE tyvar     {% ams (sLL $1 $> $ HsBracket noExt (VarBr noExt False (unLoc $2))) [mj AnnThTyQuote $1,mj AnnName $2] }
2640         | TH_TY_QUOTE gtycon    {% ams (sLL $1 $> $ HsBracket noExt (VarBr noExt False (unLoc $2))) [mj AnnThTyQuote $1,mj AnnName $2] }
2641         | TH_TY_QUOTE {- nothing -} {% reportEmptyDoubleQuotes (getLoc $1) }
2642         | '[|' exp '|]'       {% ams (sLL $1 $> $ HsBracket noExt (ExpBr noExt $2))
2643                                       (if (hasE $1) then [mj AnnOpenE $1, mu AnnCloseQ $3]
2644                                                     else [mu AnnOpenEQ $1,mu AnnCloseQ $3]) }
2645         | '[||' exp '||]'     {% ams (sLL $1 $> $ HsBracket noExt (TExpBr noExt $2))
2646                                       (if (hasE $1) then [mj AnnOpenE $1,mc $3] else [mo $1,mc $3]) }
2647         | '[t|' ctype '|]'    {% ams (sLL $1 $> $ HsBracket noExt (TypBr noExt $2)) [mo $1,mu AnnCloseQ $3] }
2648         | '[p|' infixexp '|]' {% checkPattern empty $2 >>= \p ->
2649                                       ams (sLL $1 $> $ HsBracket noExt (PatBr noExt p))
2650                                           [mo $1,mu AnnCloseQ $3] }
2651         | '[d|' cvtopbody '|]' {% ams (sLL $1 $> $ HsBracket noExt (DecBrL noExt (snd $2)))
2652                                       (mo $1:mu AnnCloseQ $3:fst $2) }
2653         | quasiquote          { sL1 $1 (HsSpliceE noExt (unLoc $1)) }
2654
2655         -- arrow notation extension
2656         | '(|' aexp2 cmdargs '|)'  {% ams (sLL $1 $> $ HsArrForm noExt $2
2657                                                            Nothing (reverse $3))
2658                                           [mu AnnOpenB $1,mu AnnCloseB $4] }
2659
2660 splice_exp :: { LHsExpr GhcPs }
2661         : TH_ID_SPLICE          {% ams (sL1 $1 $ mkHsSpliceE HasDollar
2662                                         (sL1 $1 $ HsVar noExt (sL1 $1 (mkUnqual varName
2663                                                            (getTH_ID_SPLICE $1)))))
2664                                        [mj AnnThIdSplice $1] }
2665         | '$(' exp ')'          {% ams (sLL $1 $> $ mkHsSpliceE HasParens $2)
2666                                        [mj AnnOpenPE $1,mj AnnCloseP $3] }
2667         | TH_ID_TY_SPLICE       {% ams (sL1 $1 $ mkHsSpliceTE HasDollar
2668                                         (sL1 $1 $ HsVar noExt (sL1 $1 (mkUnqual varName
2669                                                         (getTH_ID_TY_SPLICE $1)))))
2670                                        [mj AnnThIdTySplice $1] }
2671         | '$$(' exp ')'         {% ams (sLL $1 $> $ mkHsSpliceTE HasParens $2)
2672                                        [mj AnnOpenPTE $1,mj AnnCloseP $3] }
2673
2674 cmdargs :: { [LHsCmdTop GhcPs] }
2675         : cmdargs acmd                  { $2 : $1 }
2676         | {- empty -}                   { [] }
2677
2678 acmd    :: { LHsCmdTop GhcPs }
2679         : aexp2                 {% checkCommand $1 >>= \ cmd ->
2680                                     return (sL1 $1 $ HsCmdTop noExt cmd) }
2681
2682 cvtopbody :: { ([AddAnn],[LHsDecl GhcPs]) }
2683         :  '{'            cvtopdecls0 '}'      { ([mj AnnOpenC $1
2684                                                   ,mj AnnCloseC $3],$2) }
2685         |      vocurly    cvtopdecls0 close    { ([],$2) }
2686
2687 cvtopdecls0 :: { [LHsDecl GhcPs] }
2688         : topdecls_semi         { cvTopDecls $1 }
2689         | topdecls              { cvTopDecls $1 }
2690
2691 -----------------------------------------------------------------------------
2692 -- Tuple expressions
2693
2694 -- "texp" is short for tuple expressions:
2695 -- things that can appear unparenthesized as long as they're
2696 -- inside parens or delimitted by commas
2697 texp :: { LHsExpr GhcPs }
2698         : exp                           { $1 }
2699
2700         -- Note [Parsing sections]
2701         -- ~~~~~~~~~~~~~~~~~~~~~~~
2702         -- We include left and right sections here, which isn't
2703         -- technically right according to the Haskell standard.
2704         -- For example (3 +, True) isn't legal.
2705         -- However, we want to parse bang patterns like
2706         --      (!x, !y)
2707         -- and it's convenient to do so here as a section
2708         -- Then when converting expr to pattern we unravel it again
2709         -- Meanwhile, the renamer checks that real sections appear
2710         -- inside parens.
2711         | infixexp qop        { sLL $1 $> $ SectionL noExt $1 $2 }
2712         | qopm infixexp       { sLL $1 $> $ SectionR noExt $1 $2 }
2713
2714        -- View patterns get parenthesized above
2715         | exp '->' texp   {% ams (sLL $1 $> $ EViewPat noExt $1 $3) [mu AnnRarrow $2] }
2716
2717 -- Always at least one comma or bar.
2718 tup_exprs :: { ([AddAnn],SumOrTuple) }
2719            : texp commas_tup_tail
2720                           {% do { addAnnotation (gl $1) AnnComma (fst $2)
2721                                 ; return ([],Tuple ((sL1 $1 (Present noExt $1)) : snd $2)) } }
2722
2723            | texp bars    { (mvbars (fst $2), Sum 1  (snd $2 + 1) $1) }
2724
2725            | commas tup_tail
2726                 {% do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (fst $1)
2727                       ; return
2728                            ([],Tuple (map (\l -> L l missingTupArg) (fst $1) ++ $2)) } }
2729
2730            | bars texp bars0
2731                 { (mvbars (fst $1) ++ mvbars (fst $3), Sum (snd $1 + 1) (snd $1 + snd $3 + 1) $2) }
2732
2733 -- Always starts with commas; always follows an expr
2734 commas_tup_tail :: { (SrcSpan,[LHsTupArg GhcPs]) }
2735 commas_tup_tail : commas tup_tail
2736        {% do { mapM_ (\ll -> addAnnotation ll AnnComma ll) (tail $ fst $1)
2737              ; return (
2738             (head $ fst $1
2739             ,(map (\l -> L l missingTupArg) (tail $ fst $1)) ++ $2)) } }
2740
2741 -- Always follows a comma
2742 tup_tail :: { [LHsTupArg GhcPs] }
2743           : texp commas_tup_tail {% addAnnotation (gl $1) AnnComma (fst $2) >>
2744                                     return ((L (gl $1) (Present noExt $1)) : snd $2) }
2745           | texp                 { [L (gl $1) (Present noExt $1)] }
2746           | {- empty -}          { [noLoc missingTupArg] }
2747
2748 -----------------------------------------------------------------------------
2749 -- List expressions
2750
2751 -- The rules below are little bit contorted to keep lexps left-recursive while
2752 -- avoiding another shift/reduce-conflict.
2753 list :: { ([AddAnn],HsExpr GhcPs) }
2754         : texp    { ([],ExplicitList noExt Nothing [$1]) }
2755         | lexps   { ([],ExplicitList noExt Nothing (reverse (unLoc $1))) }
2756         | texp '..'             { ([mj AnnDotdot $2],
2757                                       ArithSeq noExt Nothing (From $1)) }
2758         | texp ',' exp '..'     { ([mj AnnComma $2,mj AnnDotdot $4],
2759                                   ArithSeq noExt Nothing
2760                                                              (FromThen $1 $3)) }
2761         | texp '..' exp         { ([mj AnnDotdot $2],
2762                                    ArithSeq noExt Nothing
2763                                                                (FromTo $1 $3)) }
2764         | texp ',' exp '..' exp { ([mj AnnComma $2,mj AnnDotdot $4],
2765                                     ArithSeq noExt Nothing
2766                                                 (FromThenTo $1 $3 $5)) }
2767         | texp '|' flattenedpquals
2768              {% checkMonadComp >>= \ ctxt ->
2769                 return ([mj AnnVbar $2],
2770                         mkHsComp ctxt (unLoc $3) $1) }
2771
2772 lexps :: { Located [LHsExpr GhcPs] }
2773         : lexps ',' texp          {% addAnnotation (gl $ head $ unLoc $1)
2774                                                             AnnComma (gl $2) >>
2775                                       return (sLL $1 $> (((:) $! $3) $! unLoc $1)) }
2776         | texp ',' texp            {% addAnnotation (gl $1) AnnComma (gl $2) >>
2777                                       return (sLL $1 $> [$3,$1]) }
2778
2779 -----------------------------------------------------------------------------
2780 -- List Comprehensions
2781
2782 flattenedpquals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] }
2783     : pquals   { case (unLoc $1) of
2784                     [qs] -> sL1 $1 qs
2785                     -- We just had one thing in our "parallel" list so
2786                     -- we simply return that thing directly
2787
2788                     qss -> sL1 $1 [sL1 $1 $ ParStmt noExt [ParStmtBlock noExt qs [] noSyntaxExpr |
2789                                             qs <- qss]
2790                                             noExpr noSyntaxExpr]
2791                     -- We actually found some actual parallel lists so
2792                     -- we wrap them into as a ParStmt
2793                 }
2794
2795 pquals :: { Located [[LStmt GhcPs (LHsExpr GhcPs)]] }
2796     : squals '|' pquals
2797                      {% addAnnotation (gl $ head $ unLoc $1) AnnVbar (gl $2) >>
2798                         return (sLL $1 $> (reverse (unLoc $1) : unLoc $3)) }
2799     | squals         { L (getLoc $1) [reverse (unLoc $1)] }
2800
2801 squals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] }   -- In reverse order, because the last
2802                                         -- one can "grab" the earlier ones
2803     : squals ',' transformqual
2804              {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2) >>
2805                 ams (sLL $1 $> ()) (fst $ unLoc $3) >>
2806                 return (sLL $1 $> [sLL $1 $> ((snd $ unLoc $3) (reverse (unLoc $1)))]) }
2807     | squals ',' qual
2808              {% addAnnotation (gl $ head $ unLoc $1) AnnComma (gl $2) >>
2809                 return (sLL $1 $> ($3 : unLoc $1)) }
2810     | transformqual        {% ams $1 (fst $ unLoc $1) >>
2811                               return (sLL $1 $> [L (getLoc $1) ((snd $ unLoc $1) [])]) }
2812     | qual                                { sL1 $1 [$1] }
2813 --  | transformquals1 ',' '{|' pquals '|}'   { sLL $1 $> ($4 : unLoc $1) }
2814 --  | '{|' pquals '|}'                       { sL1 $1 [$2] }
2815
2816 -- It is possible to enable bracketing (associating) qualifier lists
2817 -- by uncommenting the lines with {| |} above. Due to a lack of
2818 -- consensus on the syntax, this feature is not being used until we
2819 -- get user demand.
2820
2821 transformqual :: { Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)] -> Stmt GhcPs (LHsExpr GhcPs)) }
2822                         -- Function is applied to a list of stmts *in order*
2823     : 'then' exp               { sLL $1 $> ([mj AnnThen $1], \ss -> (mkTransformStmt ss $2)) }
2824     | 'then' exp 'by' exp      { sLL $1 $> ([mj AnnThen $1,mj AnnBy  $3],\ss -> (mkTransformByStmt ss $2 $4)) }
2825     | 'then' 'group' 'using' exp
2826              { sLL $1 $> ([mj AnnThen $1,mj AnnGroup $2,mj AnnUsing $3], \ss -> (mkGroupUsingStmt ss $4)) }
2827
2828     | 'then' 'group' 'by' exp 'using' exp
2829              { sLL $1 $> ([mj AnnThen $1,mj AnnGroup $2,mj AnnBy $3,mj AnnUsing $5], \ss -> (mkGroupByUsingStmt ss $4 $6)) }
2830
2831 -- Note that 'group' is a special_id, which means that you can enable
2832 -- TransformListComp while still using Data.List.group. However, this
2833 -- introduces a shift/reduce conflict. Happy chooses to resolve the conflict
2834 -- in by choosing the "group by" variant, which is what we want.
2835
2836 -----------------------------------------------------------------------------
2837 -- Guards
2838
2839 guardquals :: { Located [LStmt GhcPs (LHsExpr GhcPs)] }
2840     : guardquals1           { L (getLoc $1) (reverse (unLoc $1)) }
2841
2842 guardquals1 :: { Located [LStmt GhcPs (LHsExpr GhcPs)] }
2843     : guardquals1 ',' qual  {% addAnnotation (gl $ head $ unLoc $1) AnnComma
2844                                              (gl $2) >>
2845                                return (sLL $1 $> ($3 : unLoc $1)) }
2846     | qual                  { sL1 $1 [$1] }
2847
2848 -----------------------------------------------------------------------------
2849 -- Case alternatives
2850
2851 altslist :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }
2852         : '{'            alts '}'  { sLL $1 $> ((moc $1:mcc $3:(fst $ unLoc $2))
2853                                                ,(reverse (snd $ unLoc $2))) }
2854         |     vocurly    alts  close { L (getLoc $2) (fst $ unLoc $2
2855                                         ,(reverse (snd $ unLoc $2))) }
2856         | '{'                 '}'    { sLL $1 $> ([moc $1,mcc $2],[]) }
2857         |     vocurly          close { noLoc ([],[]) }
2858
2859 alts    :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }
2860         : alts1                    { sL1 $1 (fst $ unLoc $1,snd $ unLoc $1) }
2861         | ';' alts                 { sLL $1 $> ((mj AnnSemi $1:(fst $ unLoc $2))
2862                                                ,snd $ unLoc $2) }
2863
2864 alts1   :: { Located ([AddAnn],[LMatch GhcPs (LHsExpr GhcPs)]) }
2865         : alts1 ';' alt         {% if null (snd $ unLoc $1)
2866                                      then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
2867                                                   ,[$3]))
2868                                      else (ams (head $ snd $ unLoc $1)
2869                                                (mj AnnSemi $2:(fst $ unLoc $1))
2870                                            >> return (sLL $1 $> ([],$3 : (snd $ unLoc $1))) ) }
2871         | alts1 ';'             {% if null (snd $ unLoc $1)
2872                                      then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
2873                                                   ,snd $ unLoc $1))
2874                                      else (ams (head $ snd $ unLoc $1)
2875                                                (mj AnnSemi $2:(fst $ unLoc $1))
2876                                            >> return (sLL $1 $> ([],snd $ unLoc $1))) }
2877         | alt                   { sL1 $1 ([],[$1]) }
2878
2879 alt     :: { LMatch GhcPs (LHsExpr GhcPs) }
2880            : pat alt_rhs  {%ams (sLL $1 $> (Match { m_ext = noExt
2881                                                   , m_ctxt = CaseAlt
2882                                                   , m_pats = [$1]
2883                                                   , m_grhss = snd $ unLoc $2 }))
2884                                       (fst $ unLoc $2)}
2885
2886 alt_rhs :: { Located ([AddAnn],GRHSs GhcPs (LHsExpr GhcPs)) }
2887         : ralt wherebinds           { sLL $1 $> (fst $ unLoc $2,
2888                                             GRHSs noExt (unLoc $1) (snd $ unLoc $2)) }
2889
2890 ralt :: { Located [LGRHS GhcPs (LHsExpr GhcPs)] }
2891         : '->' exp            {% ams (sLL $1 $> (unguardedRHS (comb2 $1 $2) $2))
2892                                      [mu AnnRarrow $1] }
2893         | gdpats              { sL1 $1 (reverse (unLoc $1)) }
2894
2895 gdpats :: { Located [LGRHS GhcPs (LHsExpr GhcPs)] }
2896         : gdpats gdpat                  { sLL $1 $> ($2 : unLoc $1) }
2897         | gdpat                         { sL1 $1 [$1] }
2898
2899 -- layout for MultiWayIf doesn't begin with an open brace, because it's hard to
2900 -- generate the open brace in addition to the vertical bar in the lexer, and
2901 -- we don't need it.
2902 ifgdpats :: { Located ([AddAnn],[LGRHS GhcPs (LHsExpr GhcPs)]) }
2903          : '{' gdpats '}'                 { sLL $1 $> ([moc $1,mcc $3],unLoc $2)  }
2904          |     gdpats close               { sL1 $1 ([],unLoc $1) }
2905
2906 gdpat   :: { LGRHS GhcPs (LHsExpr GhcPs) }
2907         : '|' guardquals '->' exp
2908                                   {% ams (sL (comb2 $1 $>) $ GRHS noExt (unLoc $2) $4)
2909                                          [mj AnnVbar $1,mu AnnRarrow $3] }
2910
2911 -- 'pat' recognises a pattern, including one with a bang at the top
2912 --      e.g.  "!x" or "!(x,y)" or "C a b" etc
2913 -- Bangs inside are parsed as infix operator applications, so that
2914 -- we parse them right when bang-patterns are off
2915 pat     :: { LPat GhcPs }
2916 pat     :  exp          {% checkPattern empty $1 }
2917         | '!' aexp      {% amms (checkPattern empty (sLL $1 $> (SectionR noExt
2918                                                      (sL1 $1 (HsVar noExt (sL1 $1 bang_RDR))) $2)))
2919                                 [mj AnnBang $1] }
2920
2921 bindpat :: { LPat GhcPs }
2922 bindpat :  exp            {% checkPattern
2923                                 (text "Possibly caused by a missing 'do'?") $1 }
2924         | '!' aexp        {% amms (checkPattern
2925                                      (text "Possibly caused by a missing 'do'?")
2926                                      (sLL $1 $> (SectionR noExt (sL1 $1 (HsVar noExt (sL1 $1 bang_RDR))) $2)))
2927                                   [mj AnnBang $1] }
2928
2929 apat   :: { LPat GhcPs }
2930 apat    : aexp                  {% checkPattern empty $1 }
2931         | '!' aexp              {% amms (checkPattern empty
2932                                             (sLL $1 $> (SectionR noExt
2933                                                 (sL1 $1 (HsVar noExt (sL1 $1 bang_RDR))) $2)))
2934                                         [mj AnnBang $1] }
2935
2936 apats  :: { [LPat GhcPs] }
2937         : apat apats            { $1 : $2 }
2938         | {- empty -}           { [] }
2939
2940 -----------------------------------------------------------------------------
2941 -- Statement sequences
2942
2943 stmtlist :: { Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)]) }
2944         : '{'           stmts '}'       { sLL $1 $> ((moc $1:mcc $3:(fst $ unLoc $2))
2945                                              ,(reverse $ snd $ unLoc $2)) } -- AZ:performance of reverse?
2946         |     vocurly   stmts close     { L (gl $2) (fst $ unLoc $2
2947                                                     ,reverse $ snd $ unLoc $2) }
2948
2949 --      do { ;; s ; s ; ; s ;; }
2950 -- The last Stmt should be an expression, but that's hard to enforce
2951 -- here, because we need too much lookahead if we see do { e ; }
2952 -- So we use BodyStmts throughout, and switch the last one over
2953 -- in ParseUtils.checkDo instead
2954
2955 stmts :: { Located ([AddAnn],[LStmt GhcPs (LHsExpr GhcPs)]) }
2956         : stmts ';' stmt  {% if null (snd $ unLoc $1)
2957                               then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1)
2958                                                      ,$3 : (snd $ unLoc $1)))
2959                               else do
2960                                { ams (head $ snd $ unLoc $1) [mj AnnSemi $2]
2961                                ; return $ sLL $1 $> (fst $ unLoc $1,$3 :(snd $ unLoc $1)) }}
2962
2963         | stmts ';'     {% if null (snd $ unLoc $1)
2964                              then return (sLL $1 $> (mj AnnSemi $2:(fst $ unLoc $1),snd $ unLoc $1))
2965                              else do
2966                                { ams (head $ snd $ unLoc $1)
2967                                                [mj AnnSemi $2]
2968                                ; return $1 } }
2969         | stmt                   { sL1 $1 ([],[$1]) }
2970         | {- empty -}            { noLoc ([],[]) }
2971
2972
2973 -- For typing stmts at the GHCi prompt, where
2974 -- the input may consist of just comments.
2975 maybe_stmt :: { Maybe (LStmt GhcPs (LHsExpr GhcPs)) }
2976         : stmt                          { Just $1 }
2977         | {- nothing -}                 { Nothing }
2978
2979 stmt  :: { LStmt GhcPs (LHsExpr GhcPs) }
2980         : qual                          { $1 }
2981         | 'rec' stmtlist                {% ams (sLL $1 $> $ mkRecStmt (snd $ unLoc $2))
2982                                                (mj AnnRec $1:(fst $ unLoc $2)) }
2983
2984 qual  :: { LStmt GhcPs (LHsExpr GhcPs) }
2985     : bindpat '<-' exp                  {% ams (sLL $1 $> $ mkBindStmt $1 $3)
2986                                                [mu AnnLarrow $2] }
2987     | exp                               { sL1 $1 $ mkBodyStmt $1 }
2988     | 'let' binds                       {% ams (sLL $1 $>$ LetStmt noExt (snd $ unLoc $2))
2989                                                (mj AnnLet $1:(fst $ unLoc $2)) }
2990
2991 -----------------------------------------------------------------------------
2992 -- Record Field Update/Construction
2993
2994 fbinds  :: { ([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool)) }
2995         : fbinds1                       { $1 }
2996         | {- empty -}                   { ([],([], False)) }
2997
2998 fbinds1 :: { ([AddAnn],([LHsRecField GhcPs (LHsExpr GhcPs)], Bool)) }
2999         : fbind ',' fbinds1
3000                 {% addAnnotation (gl $1) AnnComma (gl $2) >>
3001                    return (case $3 of (ma,(flds, dd)) -> (ma,($1 : flds, dd))) }
3002         | fbind                         { ([],([$1], False)) }
3003         | '..'                          { ([mj AnnDotdot $1],([],   True)) }
3004
3005 fbind   :: { LHsRecField GhcPs (LHsExpr GhcPs) }
3006         : qvar '=' texp {% ams  (sLL $1 $> $ HsRecField (sL1 $1 $ mkFieldOcc $1) $3 False)
3007                                 [mj AnnEqual $2] }
3008                         -- RHS is a 'texp', allowing view patterns (Trac #6038)
3009                         -- and, incidentally, sections.  Eg
3010                         -- f (R { x = show -> s }) = ...
3011
3012         | qvar          { sLL $1 $> $ HsRecField (sL1 $1 $ mkFieldOcc $1) placeHolderPunRhs True }
3013                         -- In the punning case, use a place-holder
3014                         -- The renamer fills in the final value
3015
3016 -----------------------------------------------------------------------------
3017 -- Implicit Parameter Bindings
3018
3019 dbinds  :: { Located [LIPBind GhcPs] }
3020         : dbinds ';' dbind
3021                       {% addAnnotation (gl $ last $ unLoc $1) AnnSemi (gl $2) >>
3022                          return (let { this = $3; rest = unLoc $1 }
3023                               in rest `seq` this `seq` sLL $1 $> (this : rest)) }
3024         | dbinds ';'  {% addAnnotation (gl $ last $ unLoc $1) AnnSemi (gl $2) >>
3025                          return (sLL $1 $> (unLoc $1)) }
3026         | dbind                        { let this = $1 in this `seq` sL1 $1 [this] }
3027 --      | {- empty -}                  { [] }
3028
3029 dbind   :: { LIPBind GhcPs }
3030 dbind   : ipvar '=' exp                {% ams (sLL $1 $> (IPBind noExt (Left $1) $3))
3031                                               [mj AnnEqual $2] }
3032
3033 ipvar   :: { Located HsIPName }
3034         : IPDUPVARID            { sL1 $1 (HsIPName (getIPDUPVARID $1)) }
3035
3036 -----------------------------------------------------------------------------
3037 -- Overloaded labels
3038
3039 overloaded_label :: { Located FastString }
3040         : LABELVARID          { sL1 $1 (getLABELVARID $1) }
3041
3042 -----------------------------------------------------------------------------
3043 -- Warnings and deprecations
3044
3045 name_boolformula_opt :: { LBooleanFormula (Located RdrName) }
3046         : name_boolformula          { $1 }
3047         | {- empty -}               { noLoc mkTrue }
3048
3049 name_boolformula :: { LBooleanFormula (Located RdrName) }
3050         : name_boolformula_and                      { $1 }
3051         | name_boolformula_and '|' name_boolformula
3052                            {% aa $1 (AnnVbar, $2)
3053                               >> return (sLL $1 $> (Or [$1,$3])) }
3054
3055 name_boolformula_and :: { LBooleanFormula (Located RdrName) }
3056         : name_boolformula_and_list
3057                   { sLL (head $1) (last $1) (And ($1)) }
3058
3059 name_boolformula_and_list :: { [LBooleanFormula (Located RdrName)] }
3060         : name_boolformula_atom                               { [$1] }
3061         | name_boolformula_atom ',' name_boolformula_and_list
3062             {% aa $1 (AnnComma, $2) >> return ($1 : $3) }
3063
3064 name_boolformula_atom :: { LBooleanFormula (Located RdrName) }
3065         : '(' name_boolformula ')'  {% ams (sLL $1 $> (Parens $2)) [mop $1,mcp $3] }
3066         | name_var                  { sL1 $1 (Var $1) }
3067
3068 namelist :: { Located [Located RdrName] }
3069 namelist : name_var              { sL1 $1 [$1] }
3070          | name_var ',' namelist {% addAnnotation (gl $1) AnnComma (gl $2) >>
3071                                     return (sLL $1 $> ($1 : unLoc $3)) }
3072
3073 name_var :: { Located RdrName }
3074 name_var : var { $1 }
3075          | con { $1 }
3076
3077 -----------------------------------------
3078 -- Data constructors
3079 -- There are two different productions here as lifted list constructors
3080 -- are parsed differently.
3081
3082 qcon_nowiredlist :: { Located RdrName }
3083         : gen_qcon                     { $1 }
3084         | sysdcon_nolist               { sL1 $1 $ nameRdrName (dataConName (unLoc $1)) }
3085
3086 qcon :: { Located RdrName }
3087   : gen_qcon              { $1}
3088   | sysdcon               { sL1 $1 $ nameRdrName (dataConName (unLoc $1)) }
3089
3090 gen_qcon :: { Located RdrName }
3091   : qconid                { $1 }
3092   | '(' qconsym ')'       {% ams (sLL $1 $> (unLoc $2))
3093                                    [mop $1,mj AnnVal $2,mcp $3] }
3094
3095 con     :: { Located RdrName }
3096         : conid                 { $1 }
3097         | '(' consym ')'        {% ams (sLL $1 $> (unLoc $2))
3098                                        [mop $1,mj AnnVal $2,mcp $3] }
3099         | sysdcon               { sL1 $1 $ nameRdrName (dataConName (unLoc $1)) }
3100
3101 con_list :: { Located [Located RdrName] }
3102 con_list : con                  { sL1 $1 [$1] }
3103          | con ',' con_list     {% addAnnotation (gl $1) AnnComma (gl $2) >>
3104                                    return (sLL $1 $> ($1 : unLoc $3)) }
3105
3106 sysdcon_nolist :: { Located DataCon }  -- Wired in data constructors
3107         : '(' ')'               {% ams (sLL $1 $> unitDataCon) [mop $1,mcp $2] }
3108         | '(' commas ')'        {% ams (sLL $1 $> $ tupleDataCon Boxed (snd $2 + 1))
3109                                        (mop $1:mcp $3:(mcommas (fst $2))) }
3110         | '(#' '#)'             {% ams (sLL $1 $> $ unboxedUnitDataCon) [mo $1,mc $2] }
3111         | '(#' commas '#)'      {% ams (sLL $1 $> $ tupleDataCon Unboxed (snd $2 + 1))
3112                                        (mo $1:mc $3:(mcommas (fst $2))) }
3113
3114 sysdcon :: { Located DataCon }
3115         : sysdcon_nolist                 { $1 }
3116         | '[' ']'               {% ams (sLL $1 $> nilDataCon) [mos $1,mcs $2] }
3117
3118 conop :: { Located RdrName }
3119         : consym                { $1 }
3120         | '`' conid '`'         {% ams (sLL $1 $> (unLoc $2))
3121                                        [mj AnnBackquote $1,mj AnnVal $2
3122                                        ,mj AnnBackquote $3] }
3123
3124 qconop :: { Located RdrName }
3125         : qconsym               { $1 }
3126         | '`' qconid '`'        {% ams (sLL $1 $> (unLoc $2))
3127                                        [mj AnnBackquote $1,mj AnnVal $2
3128                                        ,mj AnnBackquote $3] }
3129
3130 ----------------------------------------------------------------------------
3131 -- Type constructors
3132
3133
3134 -- See Note [Unit tuples] in HsTypes for the distinction
3135 -- between gtycon and ntgtycon
3136 gtycon :: { Located RdrName }  -- A "general" qualified tycon, including unit tuples
3137         : ntgtycon                     { $1 }
3138         | '(' ')'                      {% ams (sLL $1 $> $ getRdrName unitTyCon)
3139                                               [mop $1,mcp $2] }
3140         | '(#' '#)'                    {% ams (sLL $1 $> $ getRdrName unboxedUnitTyCon)
3141                                               [mo $1,mc $2] }
3142
3143 ntgtycon :: { Located RdrName }  -- A "general" qualified tycon, excluding unit tuples
3144         : oqtycon               { $1 }
3145         | '(' commas ')'        {% ams (sLL $1 $> $ getRdrName (tupleTyCon Boxed
3146                                                         (snd $2 + 1)))
3147                                        (mop $1:mcp $3:(mcommas (fst $2))) }
3148         | '(#' commas '#)'      {% ams (sLL $1 $> $ getRdrName (tupleTyCon Unboxed
3149                                                         (snd $2 + 1)))
3150                                        (mo $1:mc $3:(mcommas (fst $2))) }
3151         | '(' '->' ')'          {% ams (sLL $1 $> $ getRdrName funTyCon)
3152                                        [mop $1,mu AnnRarrow $2,mcp $3] }
3153         | '[' ']'               {% ams (sLL $1 $> $ listTyCon_RDR) [mos $1,mcs $2] }
3154
3155 oqtycon :: { Located RdrName }  -- An "ordinary" qualified tycon;
3156                                 -- These can appear in export lists
3157         : qtycon                        { $1 }
3158         | '(' qtyconsym ')'             {% ams (sLL $1 $> (unLoc $2))
3159                                                [mop $1,mj AnnVal $2,mcp $3] }
3160         | '(' '~' ')'                   {% ams (sLL $1 $> $ eqTyCon_RDR)
3161                                                [mop $1,mj AnnVal $2,mcp $3] }
3162
3163 oqtycon_no_varcon :: { Located RdrName }  -- Type constructor which cannot be mistaken
3164                                           -- for variable constructor in export lists
3165                                           -- see Note [Type constructors in export list]
3166         :  qtycon            { $1 }
3167         | '(' QCONSYM ')'    {% let name = sL1 $2 $! mkQual tcClsName (getQCONSYM $2)
3168                                 in ams (sLL $1 $> (unLoc name)) [mop $1,mj AnnVal name,mcp $3] }
3169         | '(' CONSYM ')'     {% let name = sL1 $2 $! mkUnqual tcClsName (getCONSYM $2)
3170                                 in ams (sLL $1 $> (unLoc name)) [mop $1,mj AnnVal name,mcp $3] }
3171         | '(' ':' ')'        {% let name = sL1 $2 $! consDataCon_RDR
3172                                 in ams (sLL $1 $> (unLoc name)) [mop $1,mj AnnVal name,mcp $3] }
3173         | '(' '~' ')'        {% ams (sLL $1 $> $ eqTyCon_RDR) [mop $1,mj AnnTilde $2,mcp $3] }
3174
3175 {- Note [Type constructors in export list]
3176 ~~~~~~~~~~~~~~~~~~~~~
3177 Mixing type constructors and data constructors in export lists introduces
3178 ambiguity in grammar: e.g. (*) may be both a type constructor and a function.
3179
3180 -XExplicitNamespaces allows to disambiguate by explicitly prefixing type
3181 constructors with 'type' keyword.
3182
3183 This ambiguity causes reduce/reduce conflicts in parser, which are always
3184 resolved in favour of data constructors. To get rid of conflicts we demand
3185 that ambiguous type constructors (those, which are formed by the same
3186 productions as variable constructors) are always prefixed with 'type' keyword.
3187 Unambiguous type constructors may occur both with or without 'type' keyword.
3188
3189 Note that in the parser we still parse data constructors as type
3190 constructors. As such, they still end up in the type constructor namespace
3191 until after renaming when we resolve the proper namespace for each exported
3192 child.
3193 -}
3194
3195 qtyconop :: { Located RdrName } -- Qualified or unqualified
3196         : qtyconsym                     { $1 }
3197         | '`' qtycon '`'                {% ams (sLL $1 $> (unLoc $2))
3198                                                [mj AnnBackquote $1,mj AnnVal $2
3199                                                ,mj AnnBackquote $3] }
3200
3201 qtycon :: { Located RdrName }   -- Qualified or unqualified
3202         : QCONID            { sL1 $1 $! mkQual tcClsName (getQCONID $1) }
3203         | tycon             { $1 }
3204
3205 qtycondoc :: { LHsType GhcPs } -- Qualified or unqualified
3206         : qtycon            { sL1 $1                           (HsTyVar noExt NotPromoted $1)      }
3207         | qtycon docprev    { sLL $1 $> (HsDocTy noExt (sL1 $1 (HsTyVar noExt NotPromoted $1)) $2) }
3208
3209 tycon   :: { Located RdrName }  -- Unqualified
3210         : CONID                   { sL1 $1 $! mkUnqual tcClsName (getCONID $1) }
3211
3212 qtyconsym :: { Located RdrName }
3213         : QCONSYM            { sL1 $1 $! mkQual tcClsName (getQCONSYM $1) }
3214         | QVARSYM            { sL1 $1 $! mkQual tcClsName (getQVARSYM $1) }
3215         | tyconsym           { $1 }
3216
3217 -- Does not include "!", because that is used for strictness marks
3218 --               or ".", because that separates the quantified type vars from the rest
3219 tyconsym :: { Located RdrName }
3220         : CONSYM                { sL1 $1 $! mkUnqual tcClsName (getCONSYM $1) }
3221         | VARSYM                { sL1 $1 $! mkUnqual tcClsName (getVARSYM $1) }
3222         | ':'                   { sL1 $1 $! consDataCon_RDR }
3223         | '-'                   { sL1 $1 $! mkUnqual tcClsName (fsLit "-") }
3224
3225
3226 -----------------------------------------------------------------------------
3227 -- Operators
3228
3229 op      :: { Located RdrName }   -- used in infix decls
3230         : varop                 { $1 }
3231         | conop                 { $1 }
3232
3233 varop   :: { Located RdrName }
3234         : varsym                { $1 }
3235         | '`' varid '`'         {% ams (sLL $1 $> (unLoc $2))
3236                                        [mj AnnBackquote $1,mj AnnVal $2
3237                                        ,mj AnnBackquote $3] }
3238
3239 qop     :: { LHsExpr GhcPs }   -- used in sections
3240         : qvarop                { sL1 $1 $ HsVar noExt $1 }
3241         | qconop                { sL1 $1 $ HsVar noExt $1 }
3242         | hole_op               { $1 }
3243
3244 qopm    :: { LHsExpr GhcPs }   -- used in sections
3245         : qvaropm               { sL1 $1 $ HsVar noExt $1 }
3246         | qconop                { sL1 $1 $ HsVar noExt $1 }
3247         | hole_op               { $1 }
3248
3249 hole_op :: { LHsExpr GhcPs }   -- used in sections
3250 hole_op : '`' '_' '`'           {% ams (sLL $1 $> $ EWildPat noExt)
3251                                        [mj AnnBackquote $1,mj AnnVal $2
3252                                        ,mj AnnBackquote $3] }
3253
3254 qvarop :: { Located RdrName }
3255         : qvarsym               { $1 }
3256         | '`' qvarid '`'        {% ams (sLL $1 $> (unLoc $2))
3257                                        [mj AnnBackquote $1,mj AnnVal $2
3258                                        ,mj AnnBackquote $3] }
3259
3260 qvaropm :: { Located RdrName }
3261         : qvarsym_no_minus      { $1 }
3262         | '`' qvarid '`'        {% ams (sLL $1 $> (unLoc $2))
3263                                        [mj AnnBackquote $1,mj AnnVal $2
3264                                        ,mj AnnBackquote $3] }
3265
3266 -----------------------------------------------------------------------------
3267 -- Type variables
3268
3269 tyvar   :: { Located RdrName }
3270 tyvar   : tyvarid               { $1 }
3271
3272 tyvarop :: { Located RdrName }
3273 tyvarop : '`' tyvarid '`'       {% ams (sLL $1 $> (unLoc $2))
3274                                        [mj AnnBackquote $1,mj AnnVal $2
3275                                        ,mj AnnBackquote $3] }
3276         | '.'                   {% hintExplicitForall' (getLoc $1) }