1 {- Notes about the syntax of interface files
2 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
5 interface "edison" M 4 6 2 ! 406 Module M, version 4, from package 'edison',
6 Fixities version 6, rules version 2
7 Interface syntax version 406
8 ! means M contains orphans
12 import Foo ; To compile M I used nothing from Foo, but it's
13 below me in the hierarchy
15 import Foo ! @ ; Ditto, but the ! means that Foo contains orphans
16 and the @ means that Foo is a boot interface
18 import Foo :: 3 ; To compile M I used everything from Foo, which has
21 import Foo :: 3 2 6 a 1 b 3 c 7 ; To compile M I used Foo. It had
25 and some specific things besides.
31 module ParseIface ( parseIface, parseType, parseRules, parseIdInfo ) where
33 #include "HsVersions.h"
35 import HsSyn -- quite a bit of stuff
36 import RdrHsSyn -- oodles of synonyms
37 import HsTypes ( mkHsForAllTy, mkHsTupCon )
39 import Literal ( Literal(..), mkMachInt, mkMachInt64, mkMachWord, mkMachWord64 )
40 import BasicTypes ( Fixity(..), FixityDirection(..), StrictnessMark(..),
41 NewOrData(..), Version, initialVersion, Boxity(..),
44 import CostCentre ( CostCentre(..), IsCafCC(..), IsDupdCC(..) )
45 import Type ( Kind, mkArrowKind, liftedTypeKind, openTypeKind, usageTypeKind )
46 import ForeignCall ( ForeignCall(..), CCallConv(..), CCallSpec(..), CCallTarget(..) )
49 import RnMonad ( ParsedIface(..), ExportItem, IfaceDeprecs )
50 import HscTypes ( WhetherHasOrphans, IsBootInterface, GenAvailInfo(..),
51 ImportVersion, WhatsImported(..),
54 import RdrName ( RdrName, mkRdrUnqual, mkIfaceOrig )
55 import Name ( OccName )
56 import OccName ( mkSysOccFS,
57 tcName, varName, dataName, clsName, tvName,
60 import Module ( ModuleName, PackageName, mkSysModuleNameFS, mkModule )
61 import SrcLoc ( SrcLoc )
62 import CmdLineOpts ( opt_InPackage, opt_IgnoreIfacePragmas )
64 import Class ( DefMeth (..) )
67 import FastString ( tailFS )
70 %name parseIface iface
72 %name parseIdInfo id_info
73 %name parseRules rules_and_deprecs
76 %monad { P }{ thenP }{ returnP }
77 %lexer { lexer } { ITeof }
81 'case' { ITcase } -- Haskell keywords
84 'default' { ITdefault }
85 'deriving' { ITderiving }
95 'instance' { ITinstance }
98 'newtype' { ITnewtype }
100 'qualified' { ITqualified }
105 'forall' { ITforall } -- GHC extension keywords
106 'foreign' { ITforeign }
107 'export' { ITexport }
109 'dynamic' { ITdynamic }
110 'unsafe' { ITunsafe }
112 'stdcall' { ITstdcallconv }
113 'ccall' { ITccallconv }
115 '__interface' { ITinterface } -- interface keywords
116 '__export' { IT__export }
117 '__depends' { ITdepends }
118 '__forall' { IT__forall }
119 '__letrec' { ITletrec }
120 '__coerce' { ITcoerce }
121 '__inline_me' { ITinlineMe }
122 '__inline_call'{ ITinlineCall }
123 '__DEFAULT' { ITdefaultbranch }
125 '__integer' { ITinteger_lit }
126 '__float' { ITfloat_lit }
127 '__word' { ITword_lit }
128 '__int64' { ITint64_lit }
129 '__word64' { ITword64_lit }
130 '__rational' { ITrational_lit }
131 '__addr' { ITaddr_lit }
132 '__label' { ITlabel_lit }
133 '__litlit' { ITlit_lit }
134 '__string' { ITstring_lit }
135 '__ccall' { ITccall $$ }
137 '__sccC' { ITsccAllCafs }
142 '__P' { ITspecialise }
145 '__S' { ITstrict $$ }
148 '__D' { ITdeprecated }
150 '..' { ITdotdot } -- reserved symbols
162 '{' { ITocurly } -- special symbols
164 '{|' { ITocurlybar } -- special symbols
165 '|}' { ITccurlybar } -- special symbols
176 VARID { ITvarid $$ } -- identifiers
178 VARSYM { ITvarsym $$ }
179 CONSYM { ITconsym $$ }
180 QVARID { ITqvarid $$ }
181 QCONID { ITqconid $$ }
182 QVARSYM { ITqvarsym $$ }
183 QCONSYM { ITqconsym $$ }
185 IPVARID { ITipvarid $$ } -- GHC extension
187 PRAGMA { ITpragma $$ }
190 STRING { ITstring $$ }
191 INTEGER { ITinteger $$ }
192 RATIONAL { ITrational $$ }
193 CLITLIT { ITlitlit $$ }
195 UNKNOWN { ITunknown $$ }
198 iface :: { ParsedIface }
199 iface : '__interface' package mod_name
201 orphans checkVersion 'where'
207 rules_and_deprecs_part
209 pi_mod = mkModule $3 $2, -- Module itself
210 pi_vers = $4, -- Module version
212 pi_exports = (fst $5, $9), -- Exports
213 pi_usages = $10, -- Usages
214 pi_fixity = $11, -- Fixies
215 pi_insts = $12, -- Local instances
216 pi_decls = $13, -- Decls
217 pi_rules = (snd $5,fst $14), -- Rules
218 pi_deprecs = snd $14 -- Deprecations
221 -- Versions for exports and rules (optional)
222 sub_versions :: { (Version,Version) }
223 : '[' version version ']' { ($2,$3) }
224 | {- empty -} { (initialVersion, initialVersion) }
226 --------------------------------------------------------------------------
228 import_part :: { [ImportVersion OccName] }
230 | import_decl import_part { $1 : $2 }
232 import_decl :: { ImportVersion OccName }
233 import_decl : 'import' mod_name orphans is_boot whats_imported ';'
234 { ({-mkSysModuleNameFS-} $2, $3, $4, $5) }
236 orphans :: { WhetherHasOrphans }
240 is_boot :: { IsBootInterface }
244 whats_imported :: { WhatsImported OccName }
245 whats_imported : { NothingAtAll }
246 | '::' version { Everything $2 }
247 | '::' version version version name_version_pairs { Specifically $2 (Just $3) $5 $4 }
248 | '::' version version name_version_pairs { Specifically $2 Nothing $4 $3 }
250 name_version_pairs :: { [(OccName, Version)] }
251 name_version_pairs : { [] }
252 | name_version_pair name_version_pairs { $1 : $2 }
254 name_version_pair :: { (OccName, Version) }
255 name_version_pair : var_occ version { ($1, $2) }
256 | tc_occ version { ($1, $2) }
259 --------------------------------------------------------------------------
261 exports_part :: { [ExportItem] }
262 exports_part : { [] }
263 | '__export' mod_name entities ';'
264 exports_part { ({-mkSysModuleNameFS-} $2, $3) : $5 }
266 entities :: { [RdrAvailInfo] }
268 | entity entities { $1 : $2 }
270 entity :: { RdrAvailInfo }
271 entity : var_occ { Avail $1 }
272 | tc_occ { AvailTC $1 [$1] }
273 | tc_occ '|' stuff_inside { AvailTC $1 $3 }
274 | tc_occ stuff_inside { AvailTC $1 ($1:$2) }
275 -- Note that the "main name" comes at the beginning
277 stuff_inside :: { [OccName] }
278 stuff_inside : '{' val_occs '}' { $2 }
280 val_occ :: { OccName }
284 val_occs :: { [OccName] }
286 | val_occ val_occs { $1 : $2 }
289 --------------------------------------------------------------------------
291 fix_decl_part :: { [RdrNameFixitySig] }
292 fix_decl_part : {- empty -} { [] }
293 | fix_decls ';' { $1 }
295 fix_decls :: { [RdrNameFixitySig] }
297 | fix_decl fix_decls { $1 : $2 }
299 fix_decl :: { RdrNameFixitySig }
300 fix_decl : src_loc fixity prec var_or_data_name { FixitySig $4 (Fixity $3 $2) $1 }
302 fixity :: { FixityDirection }
303 fixity : 'infixl' { InfixL }
304 | 'infixr' { InfixR }
308 prec : INTEGER { fromInteger $1 }
310 -----------------------------------------------------------------------------
312 csigs :: { [RdrNameSig] }
314 | 'where' '{' csigs1 '}' { $3 }
316 csigs1 :: { [RdrNameSig] }
318 | csig ';' csigs1 { $1 : $3 }
320 csig :: { RdrNameSig }
321 csig : src_loc qvar_name '::' type { ClassOpSig $2 NoDefMeth $4 $1 }
322 | src_loc qvar_name ';' '::' type { ClassOpSig $2 GenDefMeth $5 $1 }
323 | src_loc qvar_name '=' '::' type { mkClassOpSigDM $2 $5 $1 }
325 --------------------------------------------------------------------------
327 instance_decl_part :: { [RdrNameInstDecl] }
328 instance_decl_part : {- empty -} { [] }
329 | instance_decl_part inst_decl { $2 : $1 }
331 inst_decl :: { RdrNameInstDecl }
332 inst_decl : src_loc 'instance' type '=' qvar_name ';'
334 EmptyMonoBinds {- No bindings -}
335 [] {- No user pragmas -}
336 (Just $5) {- Dfun id -}
340 --------------------------------------------------------------------------
342 decls_part :: { [(Version, RdrNameTyClDecl)] }
345 | opt_version decl ';' decls_part { ($1,$2):$4 }
347 decl :: { RdrNameTyClDecl }
348 decl : src_loc qvar_name '::' type maybe_idinfo
349 { IfaceSig $2 $4 ($5 $2) $1 }
350 | src_loc 'type' qtc_name tv_bndrs '=' type
351 { TySynonym $3 $4 $6 $1 }
352 | src_loc 'foreign' 'type' qtc_name
353 { ForeignType $4 Nothing DNType $1 }
354 | src_loc 'data' opt_decl_context qtc_name tv_bndrs constrs
355 { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 }
356 | src_loc 'newtype' opt_decl_context qtc_name tv_bndrs newtype_constr
357 { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 }
358 | src_loc 'class' opt_decl_context qtc_name tv_bndrs fds csigs
359 { mkClassDecl $3 $4 $5 $6 $7 Nothing $1 }
361 maybe_idinfo :: { RdrName -> [HsIdInfo RdrName] }
362 maybe_idinfo : {- empty -} { \_ -> [] }
363 | pragma { \x -> if opt_IgnoreIfacePragmas then []
365 POk _ id_info -> id_info
366 PFailed err -> pprPanic "IdInfo parse failed"
370 If a signature decl is being loaded, and opt_IgnoreIfacePragmas is on,
371 we toss away unfolding information.
373 Also, if the signature is loaded from a module we're importing from source,
374 we do the same. This is to avoid situations when compiling a pair of mutually
375 recursive modules, peering at unfolding info in the interface file of the other,
376 e.g., you compile A, it looks at B's interface file and may as a result change
377 its interface file. Hence, B is recompiled, maybe changing its interface file,
378 which will the unfolding info used in A to become invalid. Simple way out is to
379 just ignore unfolding info.
381 [Jan 99: I junked the second test above. If we're importing from an hi-boot
382 file there isn't going to *be* any pragma info. The above comment
383 dates from a time where we picked up a .hi file first if it existed.]
386 pragma :: { ParseResult [HsIdInfo RdrName] }
387 pragma : src_loc PRAGMA { parseIdInfo $2 PState{ bol = 0#, atbol = 1#,
393 -----------------------------------------------------------------------------
395 rules_and_deprecs_part :: { ([RdrNameRuleDecl], IfaceDeprecs) }
396 rules_and_deprecs_part : {- empty -} { ([], Nothing) }
397 | rules_prag { case $1 of
399 PFailed err -> pprPanic "Rules/Deprecations parse failed" err
402 rules_prag :: { ParseResult ([RdrNameRuleDecl], IfaceDeprecs) }
403 rules_prag : src_loc PRAGMA { parseRules $2 PState{ bol = 0#, atbol = 1#,
409 rules_and_deprecs :: { ([RdrNameRuleDecl], IfaceDeprecs) }
410 rules_and_deprecs : rule_prag deprec_prag { ($1, $2) }
413 -----------------------------------------------------------------------------
415 rule_prag :: { [RdrNameRuleDecl] }
416 rule_prag : {- empty -} { [] }
419 rules :: { [RdrNameRuleDecl] }
421 | rule ';' rules { $1:$3 }
423 rule :: { RdrNameRuleDecl }
424 rule : src_loc STRING activation rule_forall qvar_name
425 core_args '=' core_expr { IfaceRule $2 $3 $4 $5 $6 $8 $1 }
427 activation :: { Activation }
428 activation : {- empty -} { AlwaysActive }
429 | '[' INTEGER ']' { ActiveAfter (fromInteger $2) }
431 rule_forall :: { [UfBinder RdrName] }
432 rule_forall : '__forall' '{' core_bndrs '}' { $3 }
434 -----------------------------------------------------------------------------
436 deprec_prag :: { IfaceDeprecs }
437 deprec_prag : {- empty -} { Nothing }
438 | '__D' deprecs { Just $2 }
440 deprecs :: { Either DeprecTxt [(RdrName,DeprecTxt)] }
441 deprecs : STRING { Left $1 }
442 | deprec_list { Right $1 }
444 deprec_list :: { [(RdrName,DeprecTxt)] }
445 deprec_list : deprec { [$1] }
446 | deprec ';' deprec_list { $1 : $3 }
448 deprec :: { (RdrName,DeprecTxt) }
449 deprec : deprec_name STRING { ($1, $2) }
451 deprec_name :: { RdrName }
455 -----------------------------------------------------------------------------
457 version :: { Version }
458 version : INTEGER { fromInteger $1 }
460 opt_version :: { Version }
461 opt_version : version { $1 }
462 | {- empty -} { initialVersion }
464 opt_decl_context :: { RdrNameContext }
465 opt_decl_context : { [] }
466 | context '=>' { $1 }
468 ----------------------------------------------------------------------------
470 constrs :: { [RdrNameConDecl] {- empty for handwritten abstract -} }
472 | '=' constrs1 { $2 }
474 constrs1 :: { [RdrNameConDecl] }
475 constrs1 : constr { [$1] }
476 | constr '|' constrs1 { $1 : $3 }
478 constr :: { RdrNameConDecl }
479 constr : src_loc ex_stuff qdata_name batypes { mk_con_decl $3 $2 (VanillaCon $4) $1 }
480 | src_loc ex_stuff qdata_name '{' fields1 '}' { mk_con_decl $3 $2 (RecCon $5) $1 }
481 -- We use "data_fs" so as to include ()
483 newtype_constr :: { [RdrNameConDecl] {- Not allowed to be empty -} }
484 newtype_constr : src_loc '=' ex_stuff qdata_name atype { [mk_con_decl $4 $3 (VanillaCon [unbangedType $5]) $1] }
485 | src_loc '=' ex_stuff qdata_name '{' qvar_name '::' atype '}'
486 { [mk_con_decl $4 $3 (RecCon [([$6], unbangedType $8)]) $1] }
488 ex_stuff :: { ([HsTyVarBndr RdrName], RdrNameContext) }
489 ex_stuff : { ([],[]) }
490 | '__forall' tv_bndrs opt_context '=>' { ($2,$3) }
492 batypes :: { [RdrNameBangType] }
494 | batype batypes { $1 : $2 }
496 batype :: { RdrNameBangType }
497 batype : tatype { unbangedType $1 }
498 | '!' tatype { BangType MarkedStrict $2 }
499 | '!' '!' tatype { BangType MarkedUnboxed $3 }
501 fields1 :: { [([RdrName], RdrNameBangType)] }
502 fields1 : field { [$1] }
503 | field ',' fields1 { $1 : $3 }
505 field :: { ([RdrName], RdrNameBangType) }
506 field : qvar_names1 '::' ttype { ($1, unbangedType $3) }
507 | qvar_names1 '::' '!' ttype { ($1, BangType MarkedStrict $4) }
508 | qvar_names1 '::' '!' '!' ttype { ($1, BangType MarkedUnboxed $5) }
510 --------------------------------------------------------------------------
512 type :: { RdrNameHsType }
513 type : '__forall' tv_bndrs
514 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
515 | btype '->' type { HsFunTy $1 $3 }
518 opt_context :: { RdrNameContext }
522 context :: { RdrNameContext }
523 context : '(' context_list1 ')' { $2 }
524 | '{' context_list1 '}' { $2 } -- Backward compatibility
526 context_list1 :: { RdrNameContext }
527 context_list1 : class { [$1] }
528 | class ',' context_list1 { $1 : $3 }
530 class :: { HsPred RdrName }
531 class : qcls_name atypes { (HsClassP $1 $2) }
532 | ipvar_name '::' type { (HsIParam $1 $3) }
534 types0 :: { [RdrNameHsType] {- Zero or more -} }
535 types0 : {- empty -} { [ ] }
539 types2 :: { [RdrNameHsType] {- Two or more -} }
540 types2 : type ',' type { [$1,$3] }
541 | type ',' types2 { $1 : $3 }
543 btype :: { RdrNameHsType }
545 | btype atype { HsAppTy $1 $2 }
546 | '__u' atype atype { HsUsageTy $2 $3 }
548 atype :: { RdrNameHsType }
549 atype : qtc_name { HsTyVar $1 }
550 | tv_name { HsTyVar $1 }
553 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
554 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
555 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
556 | '[' type ']' { HsListTy $2 }
557 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
558 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
559 | '(' type ')' { $2 }
561 atypes :: { [RdrNameHsType] {- Zero or more -} }
563 | atype atypes { $1 : $2 }
564 --------------------------------------------------------------------------
566 -- versions of type/btype/atype that cant begin with '!' (or '.')
567 -- for use where the kind is definitely known NOT to be '$'
569 ttype :: { RdrNameHsType }
570 ttype : '__forall' tv_bndrs
571 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
572 | tbtype '->' type { HsFunTy $1 $3 }
575 tbtype :: { RdrNameHsType }
576 tbtype : tatype { $1 }
577 | tbtype atype { HsAppTy $1 $2 }
578 | '__u' atype atype { HsUsageTy $2 $3 }
580 tatype :: { RdrNameHsType }
581 tatype : qtc_name { HsTyVar $1 }
582 | tv_name { HsTyVar $1 }
583 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
584 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
585 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
586 | '[' type ']' { HsListTy $2 }
587 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
588 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
589 | '(' type ')' { $2 }
590 ---------------------------------------------------------------------
592 package :: { PackageName }
594 | {- empty -} { opt_InPackage }
595 -- Useful for .hi-boot files,
596 -- which can omit the package Id
597 -- Module loops are always within a package
599 mod_name :: { ModuleName }
600 : CONID { mkSysModuleNameFS $1 }
603 ---------------------------------------------------
604 var_fs :: { EncodedFS }
606 | 'as' { SLIT("as") }
607 | 'qualified' { SLIT("qualified") }
608 | 'hiding' { SLIT("hiding") }
609 | 'forall' { SLIT("forall") }
610 | 'foreign' { SLIT("foreign") }
611 | 'export' { SLIT("export") }
612 | 'label' { SLIT("label") }
613 | 'dynamic' { SLIT("dynamic") }
614 | 'unsafe' { SLIT("unsafe") }
615 | 'with' { SLIT("with") }
616 | 'ccall' { SLIT("ccall") }
617 | 'stdcall' { SLIT("stdcall") }
619 var_occ :: { OccName }
620 : var_fs { mkSysOccFS varName $1 }
622 var_name :: { RdrName }
623 var_name : var_occ { mkRdrUnqual $1 }
625 qvar_name :: { RdrName }
626 qvar_name : var_name { $1 }
627 | QVARID { mkIfaceOrig varName $1 }
629 ipvar_name :: { RdrName }
630 : IPVARID { mkRdrUnqual (mkSysOccFS varName (tailFS $1)) }
632 qvar_names1 :: { [RdrName] }
633 qvar_names1 : qvar_name { [$1] }
634 | qvar_name qvar_names1 { $1 : $2 }
636 var_names :: { [RdrName] }
638 | var_name var_names { $1 : $2 }
640 var_names1 :: { [RdrName] }
641 var_names1 : var_name var_names { $1 : $2 }
643 ---------------------------------------------------
645 data_occ :: { OccName }
646 : CONID { mkSysOccFS dataName $1 }
648 qdata_name :: { RdrName }
649 : data_occ { mkRdrUnqual $1 }
650 | QCONID { mkIfaceOrig dataName $1 }
652 var_or_data_name :: { RdrName }
656 ---------------------------------------------------
657 tc_occ :: { OccName }
658 : CONID { mkSysOccFS tcName $1 }
660 qtc_name :: { RdrName }
661 : tc_occ { mkRdrUnqual $1 }
662 | QCONID { mkIfaceOrig tcName $1 }
664 ---------------------------------------------------
665 qcls_name :: { RdrName }
666 : CONID { mkRdrUnqual (mkSysOccFS clsName $1) }
667 | QCONID { mkIfaceOrig clsName $1 }
669 ---------------------------------------------------
670 tv_name :: { RdrName }
671 : var_fs { mkRdrUnqual (mkSysOccFS tvName $1) }
673 tv_bndr :: { HsTyVarBndr RdrName }
674 : tv_name '::' akind { IfaceTyVar $1 $3 }
675 | tv_name { IfaceTyVar $1 liftedTypeKind }
677 tv_bndrs :: { [HsTyVarBndr RdrName] }
679 | '[' tv_bndrs1 ']' { $2 } -- Backward compatibility
681 tv_bndrs1 :: { [HsTyVarBndr RdrName] }
683 | tv_bndr tv_bndrs1 { $1 : $2 }
685 ---------------------------------------------------
686 fds :: { [([RdrName], [RdrName])] }
688 | '|' fds1 { reverse $2 }
690 fds1 :: { [([RdrName], [RdrName])] }
691 : fds1 ',' fd { $3 : $1 }
694 fd :: { ([RdrName], [RdrName]) }
695 : varids0 '->' varids0 { (reverse $1, reverse $3) }
697 varids0 :: { [RdrName] }
699 | varids0 tv_name { $2 : $1 }
701 ---------------------------------------------------
704 | akind '->' kind { mkArrowKind $1 $3 }
707 : VARSYM { if $1 == SLIT("*") then
709 else if $1 == SLIT("?") then
711 else if $1 == SLIT("\36") then
712 usageTypeKind -- dollar
713 else panic "ParseInterface: akind"
715 | '(' kind ')' { $2 }
717 --------------------------------------------------------------------------
719 id_info :: { [HsIdInfo RdrName] }
720 : id_info_item { [$1] }
721 | id_info_item id_info { $1 : $2 }
723 id_info_item :: { HsIdInfo RdrName }
724 : '__A' INTEGER { HsArity (fromInteger $2) }
725 | '__U' activation core_expr { HsUnfold $2 $3 }
726 | '__S' { HsStrictness $1 }
727 | '__C' { HsNoCafRefs }
728 | '__P' qvar_name INTEGER { HsWorker $2 (fromInteger $3) }
730 -------------------------------------------------------
731 core_expr :: { UfExpr RdrName }
732 core_expr : '\\' core_bndrs '->' core_expr { foldr UfLam $4 $2 }
733 | 'case' core_expr 'of' var_name
734 '{' core_alts '}' { UfCase $2 $4 $6 }
736 | 'let' '{' core_val_bndr '=' core_expr
737 '}' 'in' core_expr { UfLet (UfNonRec $3 $5) $8 }
738 | '__letrec' '{' rec_binds '}'
739 'in' core_expr { UfLet (UfRec $3) $6 }
741 | '__litlit' STRING atype { UfLitLit $2 $3 }
745 fexpr :: { UfExpr RdrName }
746 fexpr : fexpr core_arg { UfApp $1 $2 }
747 | scc core_aexpr { UfNote (UfSCC $1) $2 }
748 | '__inline_me' core_aexpr { UfNote UfInlineMe $2 }
749 | '__inline_call' core_aexpr { UfNote UfInlineCall $2 }
750 | '__coerce' atype core_aexpr { UfNote (UfCoerce $2) $3 }
753 core_arg :: { UfExpr RdrName }
754 : '@' atype { UfType $2 }
757 core_args :: { [UfExpr RdrName] }
759 | core_arg core_args { $1 : $2 }
761 core_aexpr :: { UfExpr RdrName } -- Atomic expressions
762 core_aexpr : qvar_name { UfVar $1 }
763 | qdata_name { UfVar $1 }
765 | core_lit { UfLit $1 }
766 | '(' core_expr ')' { $2 }
768 | '(' ')' { UfTuple (mkHsTupCon dataName Boxed []) [] }
769 | '(' comma_exprs2 ')' { UfTuple (mkHsTupCon dataName Boxed $2) $2 }
770 | '(#' comma_exprs0 '#)' { UfTuple (mkHsTupCon dataName Unboxed $2) $2 }
772 | '{' '__ccall' ccall_string type '}'
774 (is_dyn, is_casm, may_gc) = $2
776 target | is_dyn = DynamicTarget
777 | is_casm = CasmTarget $3
778 | otherwise = StaticTarget $3
780 ccall = CCallSpec target CCallConv may_gc
782 UfFCall (CCall ccall) $4
786 comma_exprs0 :: { [UfExpr RdrName] } -- Zero or more
787 comma_exprs0 : {- empty -} { [ ] }
788 | core_expr { [ $1 ] }
789 | comma_exprs2 { $1 }
791 comma_exprs2 :: { [UfExpr RdrName] } -- Two or more
792 comma_exprs2 : core_expr ',' core_expr { [$1,$3] }
793 | core_expr ',' comma_exprs2 { $1 : $3 }
795 rec_binds :: { [(UfBinder RdrName, UfExpr RdrName)] }
797 | core_val_bndr '=' core_expr ';' rec_binds { ($1,$3) : $5 }
799 core_alts :: { [UfAlt RdrName] }
801 | core_alt ';' core_alts { $1 : $3 }
803 core_alt :: { UfAlt RdrName }
804 core_alt : core_pat '->' core_expr { (fst $1, snd $1, $3) }
806 core_pat :: { (UfConAlt RdrName, [RdrName]) }
807 core_pat : core_lit { (UfLitAlt $1, []) }
808 | '__litlit' STRING atype { (UfLitLitAlt $2 $3, []) }
809 | qdata_name core_pat_names { (UfDataAlt $1, $2) }
810 | '(' ')' { (UfTupleAlt (mkHsTupCon dataName Boxed []), []) }
811 | '(' comma_var_names1 ')' { (UfTupleAlt (mkHsTupCon dataName Boxed $2), $2) }
812 | '(#' comma_var_names1 '#)' { (UfTupleAlt (mkHsTupCon dataName Unboxed $2), $2) }
813 | '__DEFAULT' { (UfDefault, []) }
814 | '(' core_pat ')' { $2 }
816 core_pat_names :: { [RdrName] }
817 core_pat_names : { [] }
818 | core_pat_name core_pat_names { $1 : $2 }
820 -- Tyvar names and variable names live in different name spaces
821 -- so they need to be signalled separately. But we don't record
822 -- types or kinds in a pattern; we work that out from the type
823 -- of the case scrutinee
824 core_pat_name :: { RdrName }
825 core_pat_name : var_name { $1 }
828 comma_var_names1 :: { [RdrName] } -- One or more
829 comma_var_names1 : var_name { [$1] }
830 | var_name ',' comma_var_names1 { $1 : $3 }
832 core_lit :: { Literal }
833 core_lit : integer { mkMachInt $1 }
834 | CHAR { MachChar $1 }
835 | STRING { MachStr $1 }
836 | rational { MachDouble $1 }
837 | '__word' integer { mkMachWord $2 }
838 | '__word64' integer { mkMachWord64 $2 }
839 | '__int64' integer { mkMachInt64 $2 }
840 | '__float' rational { MachFloat $2 }
841 | '__addr' integer { MachAddr $2 }
842 | '__label' STRING { MachLabel $2 }
844 integer :: { Integer }
846 | '-' INTEGER { (-$2) }
848 rational :: { Rational }
850 | '-' RATIONAL { (-$2) }
852 core_bndr :: { UfBinder RdrName }
853 core_bndr : core_val_bndr { $1 }
854 | core_tv_bndr { $1 }
856 core_bndrs :: { [UfBinder RdrName] }
858 | core_bndr core_bndrs { $1 : $2 }
860 core_val_bndr :: { UfBinder RdrName }
861 core_val_bndr : var_name '::' atype { UfValBinder $1 $3 }
863 core_tv_bndr :: { UfBinder RdrName }
864 core_tv_bndr : '@' tv_name '::' akind { UfTyBinder $2 $4 }
865 | '@' tv_name { UfTyBinder $2 liftedTypeKind }
867 ccall_string :: { FAST_STRING }
873 ------------------------------------------------------------------------
874 scc :: { CostCentre }
875 : '__sccC' '{' mod_name '}' { AllCafsCC $3 }
876 | '__scc' '{' cc_name mod_name cc_dup cc_caf '}'
877 { NormalCC { cc_name = $3, cc_mod = $4,
878 cc_is_dupd = $5, cc_is_caf = $6 } }
880 cc_name :: { EncodedFS }
884 cc_dup :: { IsDupdCC }
885 cc_dup : { OriginalCC }
888 cc_caf :: { IsCafCC }
892 -------------------------------------------------------------------
894 src_loc :: { SrcLoc }
895 src_loc : {% getSrcLocP }
897 -- Check the project version: this makes sure
898 -- that the project version (e.g. 407) in the interface
899 -- file is the same as that for the compiler that's reading it
900 checkVersion :: { () }
901 : {-empty-} {% checkVersion Nothing }
902 | INTEGER {% checkVersion (Just (fromInteger $1)) }
904 -------------------------------------------------------------------
909 happyError buf PState{ loc = loc } = PFailed (ifaceParseErr buf loc)
911 mk_con_decl name (ex_tvs, ex_ctxt) details loc = mkConDecl name ex_tvs ex_ctxt details loc