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 Demand ( mkStrictnessInfo )
40 import Literal ( Literal(..), mkMachInt, mkMachInt64, mkMachWord, mkMachWord64 )
41 import BasicTypes ( Fixity(..), FixityDirection(..),
42 NewOrData(..), Version, initialVersion, Boxity(..)
44 import CostCentre ( CostCentre(..), IsCafCC(..), IsDupdCC(..) )
45 import Demand ( StrictnessMark(..) )
46 import Type ( Kind, mkArrowKind, liftedTypeKind, openTypeKind, usageTypeKind )
47 import IdInfo ( InlinePragInfo(..) )
48 import ForeignCall ( ForeignCall(..), CCallConv(..), CCallSpec(..), CCallTarget(..) )
51 import RnMonad ( ParsedIface(..), ExportItem, IfaceDeprecs )
52 import HscTypes ( WhetherHasOrphans, IsBootInterface, GenAvailInfo(..),
53 ImportVersion, WhatsImported(..),
56 import RdrName ( RdrName, mkRdrUnqual, mkIfaceOrig )
57 import Name ( OccName )
58 import OccName ( mkSysOccFS,
59 tcName, varName, dataName, clsName, tvName,
62 import Module ( ModuleName, PackageName, mkSysModuleNameFS, mkModule )
63 import SrcLoc ( SrcLoc )
64 import CmdLineOpts ( opt_InPackage, opt_IgnoreIfacePragmas )
66 import Class ( DefMeth (..) )
69 import FastString ( tailFS )
72 %name parseIface iface
74 %name parseIdInfo id_info
75 %name parseRules rules_and_deprecs
78 %monad { P }{ thenP }{ returnP }
79 %lexer { lexer } { ITeof }
83 'case' { ITcase } -- Haskell keywords
86 'default' { ITdefault }
87 'deriving' { ITderiving }
97 'instance' { ITinstance }
100 'newtype' { ITnewtype }
102 'qualified' { ITqualified }
107 'forall' { ITforall } -- GHC extension keywords
108 'foreign' { ITforeign }
109 'export' { ITexport }
111 'dynamic' { ITdynamic }
112 'unsafe' { ITunsafe }
114 'stdcall' { ITstdcallconv }
115 'ccall' { ITccallconv }
117 '__interface' { ITinterface } -- interface keywords
118 '__export' { IT__export }
119 '__depends' { ITdepends }
120 '__forall' { IT__forall }
121 '__letrec' { ITletrec }
122 '__coerce' { ITcoerce }
123 '__inline_me' { ITinlineMe }
124 '__inline_call'{ ITinlineCall }
125 '__DEFAULT' { ITdefaultbranch }
127 '__integer' { ITinteger_lit }
128 '__float' { ITfloat_lit }
129 '__word' { ITword_lit }
130 '__int64' { ITint64_lit }
131 '__word64' { ITword64_lit }
132 '__rational' { ITrational_lit }
133 '__addr' { ITaddr_lit }
134 '__label' { ITlabel_lit }
135 '__litlit' { ITlit_lit }
136 '__string' { ITstring_lit }
137 '__ccall' { ITccall $$ }
139 '__sccC' { ITsccAllCafs }
144 '__P' { ITspecialise }
146 '__U' { ITunfold $$ }
147 '__S' { ITstrict $$ }
150 '__D' { ITdeprecated }
152 '..' { ITdotdot } -- reserved symbols
164 '{' { ITocurly } -- special symbols
166 '{|' { ITocurlybar } -- special symbols
167 '|}' { ITccurlybar } -- special symbols
178 VARID { ITvarid $$ } -- identifiers
180 VARSYM { ITvarsym $$ }
181 CONSYM { ITconsym $$ }
182 QVARID { ITqvarid $$ }
183 QCONID { ITqconid $$ }
184 QVARSYM { ITqvarsym $$ }
185 QCONSYM { ITqconsym $$ }
187 IPVARID { ITipvarid $$ } -- GHC extension
189 PRAGMA { ITpragma $$ }
192 STRING { ITstring $$ }
193 INTEGER { ITinteger $$ }
194 RATIONAL { ITrational $$ }
195 CLITLIT { ITlitlit $$ }
197 UNKNOWN { ITunknown $$ }
200 iface :: { ParsedIface }
201 iface : '__interface' package mod_name
203 orphans checkVersion 'where'
209 rules_and_deprecs_part
211 pi_mod = mkModule $3 $2, -- Module itself
212 pi_vers = $4, -- Module version
214 pi_exports = (fst $5, $9), -- Exports
215 pi_usages = $10, -- Usages
216 pi_fixity = $11, -- Fixies
217 pi_insts = $12, -- Local instances
218 pi_decls = $13, -- Decls
219 pi_rules = (snd $5,fst $14), -- Rules
220 pi_deprecs = snd $14 -- Deprecations
223 -- Versions for exports and rules (optional)
224 sub_versions :: { (Version,Version) }
225 : '[' version version ']' { ($2,$3) }
226 | {- empty -} { (initialVersion, initialVersion) }
228 --------------------------------------------------------------------------
230 import_part :: { [ImportVersion OccName] }
232 | import_decl import_part { $1 : $2 }
234 import_decl :: { ImportVersion OccName }
235 import_decl : 'import' mod_name orphans is_boot whats_imported ';'
236 { ({-mkSysModuleNameFS-} $2, $3, $4, $5) }
238 orphans :: { WhetherHasOrphans }
242 is_boot :: { IsBootInterface }
246 whats_imported :: { WhatsImported OccName }
247 whats_imported : { NothingAtAll }
248 | '::' version { Everything $2 }
249 | '::' version version version name_version_pairs { Specifically $2 (Just $3) $5 $4 }
250 | '::' version version name_version_pairs { Specifically $2 Nothing $4 $3 }
252 name_version_pairs :: { [(OccName, Version)] }
253 name_version_pairs : { [] }
254 | name_version_pair name_version_pairs { $1 : $2 }
256 name_version_pair :: { (OccName, Version) }
257 name_version_pair : var_occ version { ($1, $2) }
258 | tc_occ version { ($1, $2) }
261 --------------------------------------------------------------------------
263 exports_part :: { [ExportItem] }
264 exports_part : { [] }
265 | '__export' mod_name entities ';'
266 exports_part { ({-mkSysModuleNameFS-} $2, $3) : $5 }
268 entities :: { [RdrAvailInfo] }
270 | entity entities { $1 : $2 }
272 entity :: { RdrAvailInfo }
273 entity : var_occ { Avail $1 }
274 | tc_occ { AvailTC $1 [$1] }
275 | tc_occ '|' stuff_inside { AvailTC $1 $3 }
276 | tc_occ stuff_inside { AvailTC $1 ($1:$2) }
277 -- Note that the "main name" comes at the beginning
279 stuff_inside :: { [OccName] }
280 stuff_inside : '{' val_occs '}' { $2 }
282 val_occ :: { OccName }
286 val_occs :: { [OccName] }
288 | val_occ val_occs { $1 : $2 }
291 --------------------------------------------------------------------------
293 fix_decl_part :: { [RdrNameFixitySig] }
294 fix_decl_part : {- empty -} { [] }
295 | fix_decls ';' { $1 }
297 fix_decls :: { [RdrNameFixitySig] }
299 | fix_decl fix_decls { $1 : $2 }
301 fix_decl :: { RdrNameFixitySig }
302 fix_decl : src_loc fixity prec var_or_data_name { FixitySig $4 (Fixity $3 $2) $1 }
304 fixity :: { FixityDirection }
305 fixity : 'infixl' { InfixL }
306 | 'infixr' { InfixR }
310 prec : INTEGER { fromInteger $1 }
312 -----------------------------------------------------------------------------
314 csigs :: { [RdrNameSig] }
316 | 'where' '{' csigs1 '}' { $3 }
318 csigs1 :: { [RdrNameSig] }
320 | csig ';' csigs1 { $1 : $3 }
322 csig :: { RdrNameSig }
323 csig : src_loc qvar_name '::' type { ClassOpSig $2 NoDefMeth $4 $1 }
324 | src_loc qvar_name ';' '::' type { ClassOpSig $2 GenDefMeth $5 $1 }
325 | src_loc qvar_name '=' '::' type { mkClassOpSigDM $2 $5 $1 }
327 --------------------------------------------------------------------------
329 instance_decl_part :: { [RdrNameInstDecl] }
330 instance_decl_part : {- empty -} { [] }
331 | instance_decl_part inst_decl { $2 : $1 }
333 inst_decl :: { RdrNameInstDecl }
334 inst_decl : src_loc 'instance' type '=' qvar_name ';'
336 EmptyMonoBinds {- No bindings -}
337 [] {- No user pragmas -}
338 (Just $5) {- Dfun id -}
342 --------------------------------------------------------------------------
344 decls_part :: { [(Version, RdrNameTyClDecl)] }
347 | opt_version decl ';' decls_part { ($1,$2):$4 }
349 decl :: { RdrNameTyClDecl }
350 decl : src_loc qvar_name '::' type maybe_idinfo
351 { IfaceSig $2 $4 ($5 $2) $1 }
352 | src_loc 'type' qtc_name tv_bndrs '=' type
353 { TySynonym $3 $4 $6 $1 }
354 | src_loc 'foreign' 'type' qtc_name
355 { ForeignType $4 Nothing DNType $1 }
356 | src_loc 'data' opt_decl_context qtc_name tv_bndrs constrs
357 { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 }
358 | src_loc 'newtype' opt_decl_context qtc_name tv_bndrs newtype_constr
359 { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 }
360 | src_loc 'class' opt_decl_context qtc_name tv_bndrs fds csigs
361 { mkClassDecl $3 $4 $5 $6 $7 Nothing $1 }
363 maybe_idinfo :: { RdrName -> [HsIdInfo RdrName] }
364 maybe_idinfo : {- empty -} { \_ -> [] }
365 | pragma { \x -> if opt_IgnoreIfacePragmas then []
367 POk _ id_info -> id_info
368 PFailed err -> pprPanic "IdInfo parse failed"
372 If a signature decl is being loaded, and opt_IgnoreIfacePragmas is on,
373 we toss away unfolding information.
375 Also, if the signature is loaded from a module we're importing from source,
376 we do the same. This is to avoid situations when compiling a pair of mutually
377 recursive modules, peering at unfolding info in the interface file of the other,
378 e.g., you compile A, it looks at B's interface file and may as a result change
379 its interface file. Hence, B is recompiled, maybe changing its interface file,
380 which will the unfolding info used in A to become invalid. Simple way out is to
381 just ignore unfolding info.
383 [Jan 99: I junked the second test above. If we're importing from an hi-boot
384 file there isn't going to *be* any pragma info. The above comment
385 dates from a time where we picked up a .hi file first if it existed.]
388 pragma :: { ParseResult [HsIdInfo RdrName] }
389 pragma : src_loc PRAGMA { parseIdInfo $2 PState{ bol = 0#, atbol = 1#,
395 -----------------------------------------------------------------------------
397 rules_and_deprecs_part :: { ([RdrNameRuleDecl], IfaceDeprecs) }
398 rules_and_deprecs_part : {- empty -} { ([], Nothing) }
399 | rules_prag { case $1 of
401 PFailed err -> pprPanic "Rules/Deprecations parse failed" err
404 rules_prag :: { ParseResult ([RdrNameRuleDecl], IfaceDeprecs) }
405 rules_prag : src_loc PRAGMA { parseRules $2 PState{ bol = 0#, atbol = 1#,
411 rules_and_deprecs :: { ([RdrNameRuleDecl], IfaceDeprecs) }
412 rules_and_deprecs : rule_prag deprec_prag { ($1, $2) }
415 -----------------------------------------------------------------------------
417 rule_prag :: { [RdrNameRuleDecl] }
418 rule_prag : {- empty -} { [] }
421 rules :: { [RdrNameRuleDecl] }
423 | rule ';' rules { $1:$3 }
425 rule :: { RdrNameRuleDecl }
426 rule : src_loc STRING rule_forall qvar_name
427 core_args '=' core_expr { IfaceRule $2 $3 $4 $5 $7 $1 }
429 rule_forall :: { [UfBinder RdrName] }
430 rule_forall : '__forall' '{' core_bndrs '}' { $3 }
432 -----------------------------------------------------------------------------
434 deprec_prag :: { IfaceDeprecs }
435 deprec_prag : {- empty -} { Nothing }
436 | '__D' deprecs { Just $2 }
438 deprecs :: { Either DeprecTxt [(RdrName,DeprecTxt)] }
439 deprecs : STRING { Left $1 }
440 | deprec_list { Right $1 }
442 deprec_list :: { [(RdrName,DeprecTxt)] }
443 deprec_list : deprec { [$1] }
444 | deprec ';' deprec_list { $1 : $3 }
446 deprec :: { (RdrName,DeprecTxt) }
447 deprec : deprec_name STRING { ($1, $2) }
449 deprec_name :: { RdrName }
453 -----------------------------------------------------------------------------
455 version :: { Version }
456 version : INTEGER { fromInteger $1 }
458 opt_version :: { Version }
459 opt_version : version { $1 }
460 | {- empty -} { initialVersion }
462 opt_decl_context :: { RdrNameContext }
463 opt_decl_context : { [] }
464 | context '=>' { $1 }
466 ----------------------------------------------------------------------------
468 constrs :: { [RdrNameConDecl] {- empty for handwritten abstract -} }
470 | '=' constrs1 { $2 }
472 constrs1 :: { [RdrNameConDecl] }
473 constrs1 : constr { [$1] }
474 | constr '|' constrs1 { $1 : $3 }
476 constr :: { RdrNameConDecl }
477 constr : src_loc ex_stuff qdata_name batypes { mk_con_decl $3 $2 (VanillaCon $4) $1 }
478 | src_loc ex_stuff qdata_name '{' fields1 '}' { mk_con_decl $3 $2 (RecCon $5) $1 }
479 -- We use "data_fs" so as to include ()
481 newtype_constr :: { [RdrNameConDecl] {- Not allowed to be empty -} }
482 newtype_constr : src_loc '=' ex_stuff qdata_name atype { [mk_con_decl $4 $3 (VanillaCon [unbangedType $5]) $1] }
483 | src_loc '=' ex_stuff qdata_name '{' qvar_name '::' atype '}'
484 { [mk_con_decl $4 $3 (RecCon [([$6], unbangedType $8)]) $1] }
486 ex_stuff :: { ([HsTyVarBndr RdrName], RdrNameContext) }
487 ex_stuff : { ([],[]) }
488 | '__forall' tv_bndrs opt_context '=>' { ($2,$3) }
490 batypes :: { [RdrNameBangType] }
492 | batype batypes { $1 : $2 }
494 batype :: { RdrNameBangType }
495 batype : tatype { unbangedType $1 }
496 | '!' tatype { BangType MarkedStrict $2 }
497 | '!' '!' tatype { BangType MarkedUnboxed $3 }
499 fields1 :: { [([RdrName], RdrNameBangType)] }
500 fields1 : field { [$1] }
501 | field ',' fields1 { $1 : $3 }
503 field :: { ([RdrName], RdrNameBangType) }
504 field : qvar_names1 '::' ttype { ($1, unbangedType $3) }
505 | qvar_names1 '::' '!' ttype { ($1, BangType MarkedStrict $4) }
506 | qvar_names1 '::' '!' '!' ttype { ($1, BangType MarkedUnboxed $5) }
508 --------------------------------------------------------------------------
510 type :: { RdrNameHsType }
511 type : '__forall' tv_bndrs
512 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
513 | btype '->' type { HsFunTy $1 $3 }
516 opt_context :: { RdrNameContext }
520 context :: { RdrNameContext }
521 context : '(' context_list1 ')' { $2 }
522 | '{' context_list1 '}' { $2 } -- Backward compatibility
524 context_list1 :: { RdrNameContext }
525 context_list1 : class { [$1] }
526 | class ',' context_list1 { $1 : $3 }
528 class :: { HsPred RdrName }
529 class : qcls_name atypes { (HsClassP $1 $2) }
530 | ipvar_name '::' type { (HsIParam $1 $3) }
532 types0 :: { [RdrNameHsType] {- Zero or more -} }
533 types0 : {- empty -} { [ ] }
537 types2 :: { [RdrNameHsType] {- Two or more -} }
538 types2 : type ',' type { [$1,$3] }
539 | type ',' types2 { $1 : $3 }
541 btype :: { RdrNameHsType }
543 | btype atype { HsAppTy $1 $2 }
544 | '__u' atype atype { HsUsageTy $2 $3 }
546 atype :: { RdrNameHsType }
547 atype : qtc_name { HsTyVar $1 }
548 | tv_name { HsTyVar $1 }
551 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
552 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
553 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
554 | '[' type ']' { HsListTy $2 }
555 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
556 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
557 | '(' type ')' { $2 }
559 atypes :: { [RdrNameHsType] {- Zero or more -} }
561 | atype atypes { $1 : $2 }
562 --------------------------------------------------------------------------
564 -- versions of type/btype/atype that cant begin with '!' (or '.')
565 -- for use where the kind is definitely known NOT to be '$'
567 ttype :: { RdrNameHsType }
568 ttype : '__forall' tv_bndrs
569 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
570 | tbtype '->' type { HsFunTy $1 $3 }
573 tbtype :: { RdrNameHsType }
574 tbtype : tatype { $1 }
575 | tbtype atype { HsAppTy $1 $2 }
576 | '__u' atype atype { HsUsageTy $2 $3 }
578 tatype :: { RdrNameHsType }
579 tatype : qtc_name { HsTyVar $1 }
580 | tv_name { HsTyVar $1 }
581 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
582 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
583 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
584 | '[' type ']' { HsListTy $2 }
585 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
586 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
587 | '(' type ')' { $2 }
588 ---------------------------------------------------------------------
590 package :: { PackageName }
592 | {- empty -} { opt_InPackage } -- Useful for .hi-boot files,
593 -- which can omit the package Id
594 -- Module loops are always within a package
596 mod_name :: { ModuleName }
597 : CONID { mkSysModuleNameFS $1 }
600 ---------------------------------------------------
601 var_fs :: { EncodedFS }
604 | 'as' { SLIT("as") }
605 | 'qualified' { SLIT("qualified") }
606 | 'hiding' { SLIT("hiding") }
607 | 'forall' { SLIT("forall") }
608 | 'foreign' { SLIT("foreign") }
609 | 'export' { SLIT("export") }
610 | 'label' { SLIT("label") }
611 | 'dynamic' { SLIT("dynamic") }
612 | 'unsafe' { SLIT("unsafe") }
613 | 'with' { SLIT("with") }
614 | 'ccall' { SLIT("ccall") }
615 | 'stdcall' { SLIT("stdcall") }
617 qvar_fs :: { (EncodedFS, EncodedFS) }
621 var_occ :: { OccName }
622 : var_fs { mkSysOccFS varName $1 }
624 var_name :: { RdrName }
625 var_name : var_occ { mkRdrUnqual $1 }
627 qvar_name :: { RdrName }
628 qvar_name : var_name { $1 }
629 | qvar_fs { mkIfaceOrig varName $1 }
631 ipvar_name :: { RdrName }
632 : IPVARID { mkRdrUnqual (mkSysOccFS varName (tailFS $1)) }
634 qvar_names1 :: { [RdrName] }
635 qvar_names1 : qvar_name { [$1] }
636 | qvar_name qvar_names1 { $1 : $2 }
638 var_names :: { [RdrName] }
640 | var_name var_names { $1 : $2 }
642 var_names1 :: { [RdrName] }
643 var_names1 : var_name var_names { $1 : $2 }
645 ---------------------------------------------------
646 -- For some bizarre reason,
647 -- (,,,) is dealt with by the parser
648 -- Foo.(,,,) is dealt with by the lexer
651 data_fs :: { EncodedFS }
655 qdata_fs :: { (EncodedFS, EncodedFS) }
659 data_occ :: { OccName }
660 : data_fs { mkSysOccFS dataName $1 }
662 data_name :: { RdrName }
663 : data_occ { mkRdrUnqual $1 }
665 qdata_name :: { RdrName }
666 qdata_name : data_name { $1 }
667 | qdata_fs { mkIfaceOrig dataName $1 }
669 var_or_data_name :: { RdrName }
673 ---------------------------------------------------
674 tc_occ :: { OccName }
675 : data_fs { mkSysOccFS tcName $1 }
677 tc_name :: { RdrName }
678 : tc_occ { mkRdrUnqual $1 }
680 qtc_name :: { RdrName }
682 | qdata_fs { mkIfaceOrig tcName $1 }
684 ---------------------------------------------------
685 cls_name :: { RdrName }
686 : data_fs { mkRdrUnqual (mkSysOccFS clsName $1) }
688 qcls_name :: { RdrName }
690 | qdata_fs { mkIfaceOrig clsName $1 }
692 ---------------------------------------------------
693 tv_name :: { RdrName }
694 : VARID { mkRdrUnqual (mkSysOccFS tvName $1) }
696 tv_bndr :: { HsTyVarBndr RdrName }
697 : tv_name '::' akind { IfaceTyVar $1 $3 }
698 | tv_name { IfaceTyVar $1 liftedTypeKind }
700 tv_bndrs :: { [HsTyVarBndr RdrName] }
702 | '[' tv_bndrs1 ']' { $2 } -- Backward compatibility
704 tv_bndrs1 :: { [HsTyVarBndr RdrName] }
706 | tv_bndr tv_bndrs1 { $1 : $2 }
708 ---------------------------------------------------
709 fds :: { [([RdrName], [RdrName])] }
711 | '|' fds1 { reverse $2 }
713 fds1 :: { [([RdrName], [RdrName])] }
714 : fds1 ',' fd { $3 : $1 }
717 fd :: { ([RdrName], [RdrName]) }
718 : varids0 '->' varids0 { (reverse $1, reverse $3) }
720 varids0 :: { [RdrName] }
722 | varids0 tv_name { $2 : $1 }
724 ---------------------------------------------------
727 | akind '->' kind { mkArrowKind $1 $3 }
730 : VARSYM { if $1 == SLIT("*") then
732 else if $1 == SLIT("?") then
734 else if $1 == SLIT("\36") then
735 usageTypeKind -- dollar
736 else panic "ParseInterface: akind"
738 | '(' kind ')' { $2 }
740 --------------------------------------------------------------------------
742 id_info :: { [HsIdInfo RdrName] }
743 : id_info_item { [$1] }
744 | id_info_item id_info { $1 : $2 }
746 id_info_item :: { HsIdInfo RdrName }
747 : '__A' INTEGER { HsArity (fromInteger $2) }
748 | '__U' inline_prag core_expr { HsUnfold $2 $3 }
749 | '__M' { HsCprInfo }
750 | '__S' { HsStrictness (mkStrictnessInfo $1) }
751 | '__C' { HsNoCafRefs }
752 | '__P' qvar_name INTEGER { HsWorker $2 (fromInteger $3) }
754 inline_prag :: { InlinePragInfo }
755 : {- empty -} { NoInlinePragInfo }
756 | '[' from_prag phase ']' { IMustNotBeINLINEd $2 $3 }
758 from_prag :: { Bool }
759 : {- empty -} { True }
762 phase :: { Maybe Int }
763 : {- empty -} { Nothing }
764 | INTEGER { Just (fromInteger $1) }
766 -------------------------------------------------------
767 core_expr :: { UfExpr RdrName }
768 core_expr : '\\' core_bndrs '->' core_expr { foldr UfLam $4 $2 }
769 | 'case' core_expr 'of' var_name
770 '{' core_alts '}' { UfCase $2 $4 $6 }
772 | 'let' '{' core_val_bndr '=' core_expr
773 '}' 'in' core_expr { UfLet (UfNonRec $3 $5) $8 }
774 | '__letrec' '{' rec_binds '}'
775 'in' core_expr { UfLet (UfRec $3) $6 }
777 | '__litlit' STRING atype { UfLitLit $2 $3 }
781 fexpr :: { UfExpr RdrName }
782 fexpr : fexpr core_arg { UfApp $1 $2 }
783 | scc core_aexpr { UfNote (UfSCC $1) $2 }
784 | '__inline_me' core_aexpr { UfNote UfInlineMe $2 }
785 | '__inline_call' core_aexpr { UfNote UfInlineCall $2 }
786 | '__coerce' atype core_aexpr { UfNote (UfCoerce $2) $3 }
789 core_arg :: { UfExpr RdrName }
790 : '@' atype { UfType $2 }
793 core_args :: { [UfExpr RdrName] }
795 | core_arg core_args { $1 : $2 }
797 core_aexpr :: { UfExpr RdrName } -- Atomic expressions
798 core_aexpr : qvar_name { UfVar $1 }
799 | qdata_name { UfVar $1 }
801 | core_lit { UfLit $1 }
802 | '(' core_expr ')' { $2 }
804 | '(' ')' { UfTuple (mkHsTupCon dataName Boxed []) [] }
805 | '(' comma_exprs2 ')' { UfTuple (mkHsTupCon dataName Boxed $2) $2 }
806 | '(#' comma_exprs0 '#)' { UfTuple (mkHsTupCon dataName Unboxed $2) $2 }
808 | '{' '__ccall' ccall_string type '}'
810 (is_dyn, is_casm, may_gc) = $2
812 target | is_dyn = DynamicTarget
813 | is_casm = CasmTarget $3
814 | otherwise = StaticTarget $3
816 ccall = CCallSpec target CCallConv may_gc
818 UfFCall (CCall ccall) $4
822 comma_exprs0 :: { [UfExpr RdrName] } -- Zero or more
823 comma_exprs0 : {- empty -} { [ ] }
824 | core_expr { [ $1 ] }
825 | comma_exprs2 { $1 }
827 comma_exprs2 :: { [UfExpr RdrName] } -- Two or more
828 comma_exprs2 : core_expr ',' core_expr { [$1,$3] }
829 | core_expr ',' comma_exprs2 { $1 : $3 }
831 rec_binds :: { [(UfBinder RdrName, UfExpr RdrName)] }
833 | core_val_bndr '=' core_expr ';' rec_binds { ($1,$3) : $5 }
835 core_alts :: { [UfAlt RdrName] }
837 | core_alt ';' core_alts { $1 : $3 }
839 core_alt :: { UfAlt RdrName }
840 core_alt : core_pat '->' core_expr { (fst $1, snd $1, $3) }
842 core_pat :: { (UfConAlt RdrName, [RdrName]) }
843 core_pat : core_lit { (UfLitAlt $1, []) }
844 | '__litlit' STRING atype { (UfLitLitAlt $2 $3, []) }
845 | qdata_name core_pat_names { (UfDataAlt $1, $2) }
846 | '(' ')' { (UfTupleAlt (mkHsTupCon dataName Boxed []), []) }
847 | '(' comma_var_names1 ')' { (UfTupleAlt (mkHsTupCon dataName Boxed $2), $2) }
848 | '(#' comma_var_names1 '#)' { (UfTupleAlt (mkHsTupCon dataName Unboxed $2), $2) }
849 | '__DEFAULT' { (UfDefault, []) }
850 | '(' core_pat ')' { $2 }
852 core_pat_names :: { [RdrName] }
853 core_pat_names : { [] }
854 | core_pat_name core_pat_names { $1 : $2 }
856 -- Tyvar names and variable names live in different name spaces
857 -- so they need to be signalled separately. But we don't record
858 -- types or kinds in a pattern; we work that out from the type
859 -- of the case scrutinee
860 core_pat_name :: { RdrName }
861 core_pat_name : var_name { $1 }
864 comma_var_names1 :: { [RdrName] } -- One or more
865 comma_var_names1 : var_name { [$1] }
866 | var_name ',' comma_var_names1 { $1 : $3 }
868 core_lit :: { Literal }
869 core_lit : integer { mkMachInt $1 }
870 | CHAR { MachChar $1 }
871 | STRING { MachStr $1 }
872 | rational { MachDouble $1 }
873 | '__word' integer { mkMachWord $2 }
874 | '__word64' integer { mkMachWord64 $2 }
875 | '__int64' integer { mkMachInt64 $2 }
876 | '__float' rational { MachFloat $2 }
877 | '__addr' integer { MachAddr $2 }
878 | '__label' STRING { MachLabel $2 }
880 integer :: { Integer }
882 | '-' INTEGER { (-$2) }
884 rational :: { Rational }
886 | '-' RATIONAL { (-$2) }
888 core_bndr :: { UfBinder RdrName }
889 core_bndr : core_val_bndr { $1 }
890 | core_tv_bndr { $1 }
892 core_bndrs :: { [UfBinder RdrName] }
894 | core_bndr core_bndrs { $1 : $2 }
896 core_val_bndr :: { UfBinder RdrName }
897 core_val_bndr : var_name '::' atype { UfValBinder $1 $3 }
899 core_tv_bndr :: { UfBinder RdrName }
900 core_tv_bndr : '@' tv_name '::' akind { UfTyBinder $2 $4 }
901 | '@' tv_name { UfTyBinder $2 liftedTypeKind }
903 ccall_string :: { FAST_STRING }
909 ------------------------------------------------------------------------
910 scc :: { CostCentre }
911 : '__sccC' '{' mod_name '}' { AllCafsCC $3 }
912 | '__scc' '{' cc_name mod_name cc_dup cc_caf '}'
913 { NormalCC { cc_name = $3, cc_mod = $4,
914 cc_is_dupd = $5, cc_is_caf = $6 } }
916 cc_name :: { EncodedFS }
920 cc_dup :: { IsDupdCC }
921 cc_dup : { OriginalCC }
924 cc_caf :: { IsCafCC }
928 -------------------------------------------------------------------
930 src_loc :: { SrcLoc }
931 src_loc : {% getSrcLocP }
933 -- Check the project version: this makes sure
934 -- that the project version (e.g. 407) in the interface
935 -- file is the same as that for the compiler that's reading it
936 checkVersion :: { () }
937 : {-empty-} {% checkVersion Nothing }
938 | INTEGER {% checkVersion (Just (fromInteger $1)) }
940 -------------------------------------------------------------------
945 happyError buf PState{ loc = loc } = PFailed (ifaceParseErr buf loc)
947 mk_con_decl name (ex_tvs, ex_ctxt) details loc = mkConDecl name ex_tvs ex_ctxt details loc