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 IdInfo ( InlinePragInfo(..) )
47 import ForeignCall ( ForeignCall(..), CCallConv(..), CCallSpec(..), CCallTarget(..) )
50 import RnMonad ( ParsedIface(..), ExportItem, IfaceDeprecs )
51 import HscTypes ( WhetherHasOrphans, IsBootInterface, GenAvailInfo(..),
52 ImportVersion, WhatsImported(..),
55 import RdrName ( RdrName, mkRdrUnqual, mkIfaceOrig )
56 import Name ( OccName )
57 import OccName ( mkSysOccFS,
58 tcName, varName, dataName, clsName, tvName,
61 import Module ( ModuleName, PackageName, mkSysModuleNameFS, mkModule )
62 import SrcLoc ( SrcLoc )
63 import CmdLineOpts ( opt_InPackage, opt_IgnoreIfacePragmas )
65 import Class ( DefMeth (..) )
68 import FastString ( tailFS )
71 %name parseIface iface
73 %name parseIdInfo id_info
74 %name parseRules rules_and_deprecs
77 %monad { P }{ thenP }{ returnP }
78 %lexer { lexer } { ITeof }
82 'case' { ITcase } -- Haskell keywords
85 'default' { ITdefault }
86 'deriving' { ITderiving }
96 'instance' { ITinstance }
99 'newtype' { ITnewtype }
101 'qualified' { ITqualified }
106 'forall' { ITforall } -- GHC extension keywords
107 'foreign' { ITforeign }
108 'export' { ITexport }
110 'dynamic' { ITdynamic }
111 'unsafe' { ITunsafe }
113 'stdcall' { ITstdcallconv }
114 'ccall' { ITccallconv }
116 '__interface' { ITinterface } -- interface keywords
117 '__export' { IT__export }
118 '__depends' { ITdepends }
119 '__forall' { IT__forall }
120 '__letrec' { ITletrec }
121 '__coerce' { ITcoerce }
122 '__inline_me' { ITinlineMe }
123 '__inline_call'{ ITinlineCall }
124 '__DEFAULT' { ITdefaultbranch }
126 '__integer' { ITinteger_lit }
127 '__float' { ITfloat_lit }
128 '__word' { ITword_lit }
129 '__int64' { ITint64_lit }
130 '__word64' { ITword64_lit }
131 '__rational' { ITrational_lit }
132 '__addr' { ITaddr_lit }
133 '__label' { ITlabel_lit }
134 '__litlit' { ITlit_lit }
135 '__string' { ITstring_lit }
136 '__ccall' { ITccall $$ }
138 '__sccC' { ITsccAllCafs }
143 '__P' { ITspecialise }
146 '__S' { ITstrict $$ }
149 '__D' { ITdeprecated }
151 '..' { ITdotdot } -- reserved symbols
163 '{' { ITocurly } -- special symbols
165 '{|' { ITocurlybar } -- special symbols
166 '|}' { ITccurlybar } -- special symbols
177 VARID { ITvarid $$ } -- identifiers
179 VARSYM { ITvarsym $$ }
180 CONSYM { ITconsym $$ }
181 QVARID { ITqvarid $$ }
182 QCONID { ITqconid $$ }
183 QVARSYM { ITqvarsym $$ }
184 QCONSYM { ITqconsym $$ }
186 IPVARID { ITipvarid $$ } -- GHC extension
188 PRAGMA { ITpragma $$ }
191 STRING { ITstring $$ }
192 INTEGER { ITinteger $$ }
193 RATIONAL { ITrational $$ }
194 CLITLIT { ITlitlit $$ }
196 UNKNOWN { ITunknown $$ }
199 iface :: { ParsedIface }
200 iface : '__interface' package mod_name
202 orphans checkVersion 'where'
208 rules_and_deprecs_part
210 pi_mod = mkModule $3 $2, -- Module itself
211 pi_vers = $4, -- Module version
213 pi_exports = (fst $5, $9), -- Exports
214 pi_usages = $10, -- Usages
215 pi_fixity = $11, -- Fixies
216 pi_insts = $12, -- Local instances
217 pi_decls = $13, -- Decls
218 pi_rules = (snd $5,fst $14), -- Rules
219 pi_deprecs = snd $14 -- Deprecations
222 -- Versions for exports and rules (optional)
223 sub_versions :: { (Version,Version) }
224 : '[' version version ']' { ($2,$3) }
225 | {- empty -} { (initialVersion, initialVersion) }
227 --------------------------------------------------------------------------
229 import_part :: { [ImportVersion OccName] }
231 | import_decl import_part { $1 : $2 }
233 import_decl :: { ImportVersion OccName }
234 import_decl : 'import' mod_name orphans is_boot whats_imported ';'
235 { ({-mkSysModuleNameFS-} $2, $3, $4, $5) }
237 orphans :: { WhetherHasOrphans }
241 is_boot :: { IsBootInterface }
245 whats_imported :: { WhatsImported OccName }
246 whats_imported : { NothingAtAll }
247 | '::' version { Everything $2 }
248 | '::' version version version name_version_pairs { Specifically $2 (Just $3) $5 $4 }
249 | '::' version version name_version_pairs { Specifically $2 Nothing $4 $3 }
251 name_version_pairs :: { [(OccName, Version)] }
252 name_version_pairs : { [] }
253 | name_version_pair name_version_pairs { $1 : $2 }
255 name_version_pair :: { (OccName, Version) }
256 name_version_pair : var_occ version { ($1, $2) }
257 | tc_occ version { ($1, $2) }
260 --------------------------------------------------------------------------
262 exports_part :: { [ExportItem] }
263 exports_part : { [] }
264 | '__export' mod_name entities ';'
265 exports_part { ({-mkSysModuleNameFS-} $2, $3) : $5 }
267 entities :: { [RdrAvailInfo] }
269 | entity entities { $1 : $2 }
271 entity :: { RdrAvailInfo }
272 entity : var_occ { Avail $1 }
273 | tc_occ { AvailTC $1 [$1] }
274 | tc_occ '|' stuff_inside { AvailTC $1 $3 }
275 | tc_occ stuff_inside { AvailTC $1 ($1:$2) }
276 -- Note that the "main name" comes at the beginning
278 stuff_inside :: { [OccName] }
279 stuff_inside : '{' val_occs '}' { $2 }
281 val_occ :: { OccName }
285 val_occs :: { [OccName] }
287 | val_occ val_occs { $1 : $2 }
290 --------------------------------------------------------------------------
292 fix_decl_part :: { [RdrNameFixitySig] }
293 fix_decl_part : {- empty -} { [] }
294 | fix_decls ';' { $1 }
296 fix_decls :: { [RdrNameFixitySig] }
298 | fix_decl fix_decls { $1 : $2 }
300 fix_decl :: { RdrNameFixitySig }
301 fix_decl : src_loc fixity prec var_or_data_name { FixitySig $4 (Fixity $3 $2) $1 }
303 fixity :: { FixityDirection }
304 fixity : 'infixl' { InfixL }
305 | 'infixr' { InfixR }
309 prec : INTEGER { fromInteger $1 }
311 -----------------------------------------------------------------------------
313 csigs :: { [RdrNameSig] }
315 | 'where' '{' csigs1 '}' { $3 }
317 csigs1 :: { [RdrNameSig] }
319 | csig ';' csigs1 { $1 : $3 }
321 csig :: { RdrNameSig }
322 csig : src_loc qvar_name '::' type { ClassOpSig $2 NoDefMeth $4 $1 }
323 | src_loc qvar_name ';' '::' type { ClassOpSig $2 GenDefMeth $5 $1 }
324 | src_loc qvar_name '=' '::' type { mkClassOpSigDM $2 $5 $1 }
326 --------------------------------------------------------------------------
328 instance_decl_part :: { [RdrNameInstDecl] }
329 instance_decl_part : {- empty -} { [] }
330 | instance_decl_part inst_decl { $2 : $1 }
332 inst_decl :: { RdrNameInstDecl }
333 inst_decl : src_loc 'instance' type '=' qvar_name ';'
335 EmptyMonoBinds {- No bindings -}
336 [] {- No user pragmas -}
337 (Just $5) {- Dfun id -}
341 --------------------------------------------------------------------------
343 decls_part :: { [(Version, RdrNameTyClDecl)] }
346 | opt_version decl ';' decls_part { ($1,$2):$4 }
348 decl :: { RdrNameTyClDecl }
349 decl : src_loc qvar_name '::' type maybe_idinfo
350 { IfaceSig $2 $4 ($5 $2) $1 }
351 | src_loc 'type' qtc_name tv_bndrs '=' type
352 { TySynonym $3 $4 $6 $1 }
353 | src_loc 'foreign' 'type' qtc_name
354 { ForeignType $4 Nothing DNType $1 }
355 | src_loc 'data' opt_decl_context qtc_name tv_bndrs constrs
356 { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 }
357 | src_loc 'newtype' opt_decl_context qtc_name tv_bndrs newtype_constr
358 { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 }
359 | src_loc 'class' opt_decl_context qtc_name tv_bndrs fds csigs
360 { mkClassDecl $3 $4 $5 $6 $7 Nothing $1 }
362 maybe_idinfo :: { RdrName -> [HsIdInfo RdrName] }
363 maybe_idinfo : {- empty -} { \_ -> [] }
364 | pragma { \x -> if opt_IgnoreIfacePragmas then []
366 POk _ id_info -> id_info
367 PFailed err -> pprPanic "IdInfo parse failed"
371 If a signature decl is being loaded, and opt_IgnoreIfacePragmas is on,
372 we toss away unfolding information.
374 Also, if the signature is loaded from a module we're importing from source,
375 we do the same. This is to avoid situations when compiling a pair of mutually
376 recursive modules, peering at unfolding info in the interface file of the other,
377 e.g., you compile A, it looks at B's interface file and may as a result change
378 its interface file. Hence, B is recompiled, maybe changing its interface file,
379 which will the unfolding info used in A to become invalid. Simple way out is to
380 just ignore unfolding info.
382 [Jan 99: I junked the second test above. If we're importing from an hi-boot
383 file there isn't going to *be* any pragma info. The above comment
384 dates from a time where we picked up a .hi file first if it existed.]
387 pragma :: { ParseResult [HsIdInfo RdrName] }
388 pragma : src_loc PRAGMA { parseIdInfo $2 PState{ bol = 0#, atbol = 1#,
394 -----------------------------------------------------------------------------
396 rules_and_deprecs_part :: { ([RdrNameRuleDecl], IfaceDeprecs) }
397 rules_and_deprecs_part : {- empty -} { ([], Nothing) }
398 | rules_prag { case $1 of
400 PFailed err -> pprPanic "Rules/Deprecations parse failed" err
403 rules_prag :: { ParseResult ([RdrNameRuleDecl], IfaceDeprecs) }
404 rules_prag : src_loc PRAGMA { parseRules $2 PState{ bol = 0#, atbol = 1#,
410 rules_and_deprecs :: { ([RdrNameRuleDecl], IfaceDeprecs) }
411 rules_and_deprecs : rule_prag deprec_prag { ($1, $2) }
414 -----------------------------------------------------------------------------
416 rule_prag :: { [RdrNameRuleDecl] }
417 rule_prag : {- empty -} { [] }
420 rules :: { [RdrNameRuleDecl] }
422 | rule ';' rules { $1:$3 }
424 rule :: { RdrNameRuleDecl }
425 rule : src_loc STRING activation rule_forall qvar_name
426 core_args '=' core_expr { IfaceRule $2 $3 $4 $5 $6 $8 $1 }
428 activation :: { Activation }
429 activation : {- empty -} { AlwaysActive }
430 | '[' INTEGER ']' { ActiveAfter (fromInteger $2) }
432 rule_forall :: { [UfBinder RdrName] }
433 rule_forall : '__forall' '{' core_bndrs '}' { $3 }
435 -----------------------------------------------------------------------------
437 deprec_prag :: { IfaceDeprecs }
438 deprec_prag : {- empty -} { Nothing }
439 | '__D' deprecs { Just $2 }
441 deprecs :: { Either DeprecTxt [(RdrName,DeprecTxt)] }
442 deprecs : STRING { Left $1 }
443 | deprec_list { Right $1 }
445 deprec_list :: { [(RdrName,DeprecTxt)] }
446 deprec_list : deprec { [$1] }
447 | deprec ';' deprec_list { $1 : $3 }
449 deprec :: { (RdrName,DeprecTxt) }
450 deprec : deprec_name STRING { ($1, $2) }
452 deprec_name :: { RdrName }
456 -----------------------------------------------------------------------------
458 version :: { Version }
459 version : INTEGER { fromInteger $1 }
461 opt_version :: { Version }
462 opt_version : version { $1 }
463 | {- empty -} { initialVersion }
465 opt_decl_context :: { RdrNameContext }
466 opt_decl_context : { [] }
467 | context '=>' { $1 }
469 ----------------------------------------------------------------------------
471 constrs :: { [RdrNameConDecl] {- empty for handwritten abstract -} }
473 | '=' constrs1 { $2 }
475 constrs1 :: { [RdrNameConDecl] }
476 constrs1 : constr { [$1] }
477 | constr '|' constrs1 { $1 : $3 }
479 constr :: { RdrNameConDecl }
480 constr : src_loc ex_stuff qdata_name batypes { mk_con_decl $3 $2 (VanillaCon $4) $1 }
481 | src_loc ex_stuff qdata_name '{' fields1 '}' { mk_con_decl $3 $2 (RecCon $5) $1 }
482 -- We use "data_fs" so as to include ()
484 newtype_constr :: { [RdrNameConDecl] {- Not allowed to be empty -} }
485 newtype_constr : src_loc '=' ex_stuff qdata_name atype { [mk_con_decl $4 $3 (VanillaCon [unbangedType $5]) $1] }
486 | src_loc '=' ex_stuff qdata_name '{' qvar_name '::' atype '}'
487 { [mk_con_decl $4 $3 (RecCon [([$6], unbangedType $8)]) $1] }
489 ex_stuff :: { ([HsTyVarBndr RdrName], RdrNameContext) }
490 ex_stuff : { ([],[]) }
491 | '__forall' tv_bndrs opt_context '=>' { ($2,$3) }
493 batypes :: { [RdrNameBangType] }
495 | batype batypes { $1 : $2 }
497 batype :: { RdrNameBangType }
498 batype : tatype { unbangedType $1 }
499 | '!' tatype { BangType MarkedStrict $2 }
500 | '!' '!' tatype { BangType MarkedUnboxed $3 }
502 fields1 :: { [([RdrName], RdrNameBangType)] }
503 fields1 : field { [$1] }
504 | field ',' fields1 { $1 : $3 }
506 field :: { ([RdrName], RdrNameBangType) }
507 field : qvar_names1 '::' ttype { ($1, unbangedType $3) }
508 | qvar_names1 '::' '!' ttype { ($1, BangType MarkedStrict $4) }
509 | qvar_names1 '::' '!' '!' ttype { ($1, BangType MarkedUnboxed $5) }
511 --------------------------------------------------------------------------
513 type :: { RdrNameHsType }
514 type : '__forall' tv_bndrs
515 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
516 | btype '->' type { HsFunTy $1 $3 }
519 opt_context :: { RdrNameContext }
523 context :: { RdrNameContext }
524 context : '(' context_list1 ')' { $2 }
525 | '{' context_list1 '}' { $2 } -- Backward compatibility
527 context_list1 :: { RdrNameContext }
528 context_list1 : class { [$1] }
529 | class ',' context_list1 { $1 : $3 }
531 class :: { HsPred RdrName }
532 class : qcls_name atypes { (HsClassP $1 $2) }
533 | ipvar_name '::' type { (HsIParam $1 $3) }
535 types0 :: { [RdrNameHsType] {- Zero or more -} }
536 types0 : {- empty -} { [ ] }
540 types2 :: { [RdrNameHsType] {- Two or more -} }
541 types2 : type ',' type { [$1,$3] }
542 | type ',' types2 { $1 : $3 }
544 btype :: { RdrNameHsType }
546 | btype atype { HsAppTy $1 $2 }
547 | '__u' atype atype { HsUsageTy $2 $3 }
549 atype :: { RdrNameHsType }
550 atype : qtc_name { HsTyVar $1 }
551 | tv_name { HsTyVar $1 }
554 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
555 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
556 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
557 | '[' type ']' { HsListTy $2 }
558 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
559 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
560 | '(' type ')' { $2 }
562 atypes :: { [RdrNameHsType] {- Zero or more -} }
564 | atype atypes { $1 : $2 }
565 --------------------------------------------------------------------------
567 -- versions of type/btype/atype that cant begin with '!' (or '.')
568 -- for use where the kind is definitely known NOT to be '$'
570 ttype :: { RdrNameHsType }
571 ttype : '__forall' tv_bndrs
572 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
573 | tbtype '->' type { HsFunTy $1 $3 }
576 tbtype :: { RdrNameHsType }
577 tbtype : tatype { $1 }
578 | tbtype atype { HsAppTy $1 $2 }
579 | '__u' atype atype { HsUsageTy $2 $3 }
581 tatype :: { RdrNameHsType }
582 tatype : qtc_name { HsTyVar $1 }
583 | tv_name { HsTyVar $1 }
584 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
585 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
586 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
587 | '[' type ']' { HsListTy $2 }
588 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
589 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
590 | '(' type ')' { $2 }
591 ---------------------------------------------------------------------
593 package :: { PackageName }
595 | {- empty -} { opt_InPackage }
596 -- Useful for .hi-boot files,
597 -- which can omit the package Id
598 -- Module loops are always within a package
600 mod_name :: { ModuleName }
601 : CONID { mkSysModuleNameFS $1 }
604 ---------------------------------------------------
605 var_fs :: { EncodedFS }
607 | 'as' { SLIT("as") }
608 | 'qualified' { SLIT("qualified") }
609 | 'hiding' { SLIT("hiding") }
610 | 'forall' { SLIT("forall") }
611 | 'foreign' { SLIT("foreign") }
612 | 'export' { SLIT("export") }
613 | 'label' { SLIT("label") }
614 | 'dynamic' { SLIT("dynamic") }
615 | 'unsafe' { SLIT("unsafe") }
616 | 'with' { SLIT("with") }
617 | 'ccall' { SLIT("ccall") }
618 | 'stdcall' { SLIT("stdcall") }
620 var_occ :: { OccName }
621 : var_fs { mkSysOccFS varName $1 }
623 var_name :: { RdrName }
624 var_name : var_occ { mkRdrUnqual $1 }
626 qvar_name :: { RdrName }
627 qvar_name : var_name { $1 }
628 | QVARID { mkIfaceOrig varName $1 }
630 ipvar_name :: { RdrName }
631 : IPVARID { mkRdrUnqual (mkSysOccFS varName (tailFS $1)) }
633 qvar_names1 :: { [RdrName] }
634 qvar_names1 : qvar_name { [$1] }
635 | qvar_name qvar_names1 { $1 : $2 }
637 var_names :: { [RdrName] }
639 | var_name var_names { $1 : $2 }
641 var_names1 :: { [RdrName] }
642 var_names1 : var_name var_names { $1 : $2 }
644 ---------------------------------------------------
646 data_occ :: { OccName }
647 : CONID { mkSysOccFS dataName $1 }
649 qdata_name :: { RdrName }
650 : data_occ { mkRdrUnqual $1 }
651 | QCONID { mkIfaceOrig dataName $1 }
653 var_or_data_name :: { RdrName }
657 ---------------------------------------------------
658 tc_occ :: { OccName }
659 : CONID { mkSysOccFS tcName $1 }
661 qtc_name :: { RdrName }
662 : tc_occ { mkRdrUnqual $1 }
663 | QCONID { mkIfaceOrig tcName $1 }
665 ---------------------------------------------------
666 qcls_name :: { RdrName }
667 : CONID { mkRdrUnqual (mkSysOccFS clsName $1) }
668 | QCONID { mkIfaceOrig clsName $1 }
670 ---------------------------------------------------
671 tv_name :: { RdrName }
672 : var_fs { mkRdrUnqual (mkSysOccFS tvName $1) }
674 tv_bndr :: { HsTyVarBndr RdrName }
675 : tv_name '::' akind { IfaceTyVar $1 $3 }
676 | tv_name { IfaceTyVar $1 liftedTypeKind }
678 tv_bndrs :: { [HsTyVarBndr RdrName] }
680 | '[' tv_bndrs1 ']' { $2 } -- Backward compatibility
682 tv_bndrs1 :: { [HsTyVarBndr RdrName] }
684 | tv_bndr tv_bndrs1 { $1 : $2 }
686 ---------------------------------------------------
687 fds :: { [([RdrName], [RdrName])] }
689 | '|' fds1 { reverse $2 }
691 fds1 :: { [([RdrName], [RdrName])] }
692 : fds1 ',' fd { $3 : $1 }
695 fd :: { ([RdrName], [RdrName]) }
696 : varids0 '->' varids0 { (reverse $1, reverse $3) }
698 varids0 :: { [RdrName] }
700 | varids0 tv_name { $2 : $1 }
702 ---------------------------------------------------
705 | akind '->' kind { mkArrowKind $1 $3 }
708 : VARSYM { if $1 == SLIT("*") then
710 else if $1 == SLIT("?") then
712 else if $1 == SLIT("\36") then
713 usageTypeKind -- dollar
714 else panic "ParseInterface: akind"
716 | '(' kind ')' { $2 }
718 --------------------------------------------------------------------------
720 id_info :: { [HsIdInfo RdrName] }
721 : id_info_item { [$1] }
722 | id_info_item id_info { $1 : $2 }
724 id_info_item :: { HsIdInfo RdrName }
725 : '__A' INTEGER { HsArity (fromInteger $2) }
726 | '__U' activation core_expr { HsUnfold $2 $3 }
727 | '__S' { HsStrictness $1 }
728 | '__C' { HsNoCafRefs }
729 | '__P' qvar_name INTEGER { HsWorker $2 (fromInteger $3) }
731 -------------------------------------------------------
732 core_expr :: { UfExpr RdrName }
733 core_expr : '\\' core_bndrs '->' core_expr { foldr UfLam $4 $2 }
734 | 'case' core_expr 'of' var_name
735 '{' core_alts '}' { UfCase $2 $4 $6 }
737 | 'let' '{' core_val_bndr '=' core_expr
738 '}' 'in' core_expr { UfLet (UfNonRec $3 $5) $8 }
739 | '__letrec' '{' rec_binds '}'
740 'in' core_expr { UfLet (UfRec $3) $6 }
742 | '__litlit' STRING atype { UfLitLit $2 $3 }
746 fexpr :: { UfExpr RdrName }
747 fexpr : fexpr core_arg { UfApp $1 $2 }
748 | scc core_aexpr { UfNote (UfSCC $1) $2 }
749 | '__inline_me' core_aexpr { UfNote UfInlineMe $2 }
750 | '__inline_call' core_aexpr { UfNote UfInlineCall $2 }
751 | '__coerce' atype core_aexpr { UfNote (UfCoerce $2) $3 }
754 core_arg :: { UfExpr RdrName }
755 : '@' atype { UfType $2 }
758 core_args :: { [UfExpr RdrName] }
760 | core_arg core_args { $1 : $2 }
762 core_aexpr :: { UfExpr RdrName } -- Atomic expressions
763 core_aexpr : qvar_name { UfVar $1 }
764 | qdata_name { UfVar $1 }
766 | core_lit { UfLit $1 }
767 | '(' core_expr ')' { $2 }
769 | '(' ')' { UfTuple (mkHsTupCon dataName Boxed []) [] }
770 | '(' comma_exprs2 ')' { UfTuple (mkHsTupCon dataName Boxed $2) $2 }
771 | '(#' comma_exprs0 '#)' { UfTuple (mkHsTupCon dataName Unboxed $2) $2 }
773 | '{' '__ccall' ccall_string type '}'
775 (is_dyn, is_casm, may_gc) = $2
777 target | is_dyn = DynamicTarget
778 | is_casm = CasmTarget $3
779 | otherwise = StaticTarget $3
781 ccall = CCallSpec target CCallConv may_gc
783 UfFCall (CCall ccall) $4
787 comma_exprs0 :: { [UfExpr RdrName] } -- Zero or more
788 comma_exprs0 : {- empty -} { [ ] }
789 | core_expr { [ $1 ] }
790 | comma_exprs2 { $1 }
792 comma_exprs2 :: { [UfExpr RdrName] } -- Two or more
793 comma_exprs2 : core_expr ',' core_expr { [$1,$3] }
794 | core_expr ',' comma_exprs2 { $1 : $3 }
796 rec_binds :: { [(UfBinder RdrName, UfExpr RdrName)] }
798 | core_val_bndr '=' core_expr ';' rec_binds { ($1,$3) : $5 }
800 core_alts :: { [UfAlt RdrName] }
802 | core_alt ';' core_alts { $1 : $3 }
804 core_alt :: { UfAlt RdrName }
805 core_alt : core_pat '->' core_expr { (fst $1, snd $1, $3) }
807 core_pat :: { (UfConAlt RdrName, [RdrName]) }
808 core_pat : core_lit { (UfLitAlt $1, []) }
809 | '__litlit' STRING atype { (UfLitLitAlt $2 $3, []) }
810 | qdata_name core_pat_names { (UfDataAlt $1, $2) }
811 | '(' ')' { (UfTupleAlt (mkHsTupCon dataName Boxed []), []) }
812 | '(' comma_var_names1 ')' { (UfTupleAlt (mkHsTupCon dataName Boxed $2), $2) }
813 | '(#' comma_var_names1 '#)' { (UfTupleAlt (mkHsTupCon dataName Unboxed $2), $2) }
814 | '__DEFAULT' { (UfDefault, []) }
815 | '(' core_pat ')' { $2 }
817 core_pat_names :: { [RdrName] }
818 core_pat_names : { [] }
819 | core_pat_name core_pat_names { $1 : $2 }
821 -- Tyvar names and variable names live in different name spaces
822 -- so they need to be signalled separately. But we don't record
823 -- types or kinds in a pattern; we work that out from the type
824 -- of the case scrutinee
825 core_pat_name :: { RdrName }
826 core_pat_name : var_name { $1 }
829 comma_var_names1 :: { [RdrName] } -- One or more
830 comma_var_names1 : var_name { [$1] }
831 | var_name ',' comma_var_names1 { $1 : $3 }
833 core_lit :: { Literal }
834 core_lit : integer { mkMachInt $1 }
835 | CHAR { MachChar $1 }
836 | STRING { MachStr $1 }
837 | rational { MachDouble $1 }
838 | '__word' integer { mkMachWord $2 }
839 | '__word64' integer { mkMachWord64 $2 }
840 | '__int64' integer { mkMachInt64 $2 }
841 | '__float' rational { MachFloat $2 }
842 | '__addr' integer { MachAddr $2 }
843 | '__label' STRING { MachLabel $2 }
845 integer :: { Integer }
847 | '-' INTEGER { (-$2) }
849 rational :: { Rational }
851 | '-' RATIONAL { (-$2) }
853 core_bndr :: { UfBinder RdrName }
854 core_bndr : core_val_bndr { $1 }
855 | core_tv_bndr { $1 }
857 core_bndrs :: { [UfBinder RdrName] }
859 | core_bndr core_bndrs { $1 : $2 }
861 core_val_bndr :: { UfBinder RdrName }
862 core_val_bndr : var_name '::' atype { UfValBinder $1 $3 }
864 core_tv_bndr :: { UfBinder RdrName }
865 core_tv_bndr : '@' tv_name '::' akind { UfTyBinder $2 $4 }
866 | '@' tv_name { UfTyBinder $2 liftedTypeKind }
868 ccall_string :: { FAST_STRING }
874 ------------------------------------------------------------------------
875 scc :: { CostCentre }
876 : '__sccC' '{' mod_name '}' { AllCafsCC $3 }
877 | '__scc' '{' cc_name mod_name cc_dup cc_caf '}'
878 { NormalCC { cc_name = $3, cc_mod = $4,
879 cc_is_dupd = $5, cc_is_caf = $6 } }
881 cc_name :: { EncodedFS }
885 cc_dup :: { IsDupdCC }
886 cc_dup : { OriginalCC }
889 cc_caf :: { IsCafCC }
893 -------------------------------------------------------------------
895 src_loc :: { SrcLoc }
896 src_loc : {% getSrcLocP }
898 -- Check the project version: this makes sure
899 -- that the project version (e.g. 407) in the interface
900 -- file is the same as that for the compiler that's reading it
901 checkVersion :: { () }
902 : {-empty-} {% checkVersion Nothing }
903 | INTEGER {% checkVersion (Just (fromInteger $1)) }
905 -------------------------------------------------------------------
910 happyError buf PState{ loc = loc } = PFailed (ifaceParseErr buf loc)
912 mk_con_decl name (ex_tvs, ex_ctxt) details loc = mkConDecl name ex_tvs ex_ctxt details loc