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, IfaceStuff(..) ) 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 CallConv ( cCallConv )
46 import Type ( Kind, mkArrowKind, boxedTypeKind, openTypeKind, usageTypeKind )
47 import IdInfo ( exactArity, InlinePragInfo(..) )
48 import PrimOp ( CCall(..), 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, ipName, 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 )
74 %monad { P }{ thenP }{ returnP }
75 %lexer { lexer } { ITeof }
79 'case' { ITcase } -- Haskell keywords
82 'default' { ITdefault }
83 'deriving' { ITderiving }
93 'instance' { ITinstance }
96 'newtype' { ITnewtype }
98 'qualified' { ITqualified }
103 'forall' { ITforall } -- GHC extension keywords
104 'foreign' { ITforeign }
105 'export' { ITexport }
107 'dynamic' { ITdynamic }
108 'unsafe' { ITunsafe }
110 'stdcall' { ITstdcallconv }
111 'ccall' { ITccallconv }
113 '__interface' { ITinterface } -- interface keywords
114 '__export' { IT__export }
115 '__depends' { ITdepends }
116 '__forall' { IT__forall }
117 '__letrec' { ITletrec }
118 '__coerce' { ITcoerce }
119 '__inline_me' { ITinlineMe }
120 '__inline_call'{ ITinlineCall }
121 '__DEFAULT' { ITdefaultbranch }
123 '__integer' { ITinteger_lit }
124 '__float' { ITfloat_lit }
125 '__word' { ITword_lit }
126 '__int64' { ITint64_lit }
127 '__word64' { ITword64_lit }
128 '__rational' { ITrational_lit }
129 '__addr' { ITaddr_lit }
130 '__label' { ITlabel_lit }
131 '__litlit' { ITlit_lit }
132 '__string' { ITstring_lit }
133 '__ccall' { ITccall $$ }
135 '__sccC' { ITsccAllCafs }
140 '__P' { ITspecialise }
142 '__U' { ITunfold $$ }
143 '__S' { ITstrict $$ }
146 '__D' { ITdeprecated }
148 '..' { ITdotdot } -- reserved symbols
160 '{' { ITocurly } -- special symbols
162 '{|' { ITocurlybar } -- special symbols
163 '|}' { ITccurlybar } -- special symbols
174 VARID { ITvarid $$ } -- identifiers
176 VARSYM { ITvarsym $$ }
177 CONSYM { ITconsym $$ }
178 QVARID { ITqvarid $$ }
179 QCONID { ITqconid $$ }
180 QVARSYM { ITqvarsym $$ }
181 QCONSYM { ITqconsym $$ }
183 IPVARID { ITipvarid $$ } -- GHC extension
185 PRAGMA { ITpragma $$ }
188 STRING { ITstring $$ }
189 INTEGER { ITinteger $$ }
190 RATIONAL { ITrational $$ }
191 CLITLIT { ITlitlit $$ }
193 UNKNOWN { ITunknown $$ }
196 -- iface_stuff is the main production.
197 -- It recognises (a) a whole interface file
198 -- (b) a type (so that type sigs can be parsed lazily)
199 -- (c) the IdInfo part of a signature (same reason)
201 iface_stuff :: { IfaceStuff }
202 iface_stuff : iface { PIface $1 }
204 | id_info { PIdInfo $1 }
205 | rules_and_deprecs { PRulesAndDeprecs $1 }
207 iface :: { ParsedIface }
208 iface : '__interface' package mod_name
210 orphans checkVersion 'where'
216 rules_and_deprecs_part
218 pi_mod = mkModule $3 $2, -- Module itself
219 pi_vers = $4, -- Module version
221 pi_exports = (fst $5, $9), -- Exports
222 pi_usages = $10, -- Usages
223 pi_fixity = $11, -- Fixies
224 pi_insts = $12, -- Local instances
225 pi_decls = $13, -- Decls
226 pi_rules = (snd $5,fst $14), -- Rules
227 pi_deprecs = snd $14 -- Deprecations
230 -- Versions for exports and rules (optional)
231 sub_versions :: { (Version,Version) }
232 : '[' version version ']' { ($2,$3) }
233 | {- empty -} { (initialVersion, initialVersion) }
235 --------------------------------------------------------------------------
237 import_part :: { [ImportVersion OccName] }
239 | import_decl import_part { $1 : $2 }
241 import_decl :: { ImportVersion OccName }
242 import_decl : 'import' mod_name orphans is_boot whats_imported ';'
243 { ({-mkSysModuleNameFS-} $2, $3, $4, $5) }
245 orphans :: { WhetherHasOrphans }
249 is_boot :: { IsBootInterface }
253 whats_imported :: { WhatsImported OccName }
254 whats_imported : { NothingAtAll }
255 | '::' version { Everything $2 }
256 | '::' version version version name_version_pairs { Specifically $2 (Just $3) $5 $4 }
257 | '::' version version name_version_pairs { Specifically $2 Nothing $4 $3 }
259 name_version_pairs :: { [(OccName, Version)] }
260 name_version_pairs : { [] }
261 | name_version_pair name_version_pairs { $1 : $2 }
263 name_version_pair :: { (OccName, Version) }
264 name_version_pair : var_occ version { ($1, $2) }
265 | tc_occ version { ($1, $2) }
268 --------------------------------------------------------------------------
270 exports_part :: { [ExportItem] }
271 exports_part : { [] }
272 | '__export' mod_name entities ';'
273 exports_part { ({-mkSysModuleNameFS-} $2, $3) : $5 }
275 entities :: { [RdrAvailInfo] }
277 | entity entities { $1 : $2 }
279 entity :: { RdrAvailInfo }
280 entity : var_occ { Avail $1 }
281 | tc_occ { AvailTC $1 [$1] }
282 | tc_occ '|' stuff_inside { AvailTC $1 $3 }
283 | tc_occ stuff_inside { AvailTC $1 ($1:$2) }
284 -- Note that the "main name" comes at the beginning
286 stuff_inside :: { [OccName] }
287 stuff_inside : '{' val_occs '}' { $2 }
289 val_occ :: { OccName }
293 val_occs :: { [OccName] }
295 | val_occ val_occs { $1 : $2 }
298 --------------------------------------------------------------------------
300 fix_decl_part :: { [RdrNameFixitySig] }
301 fix_decl_part : {- empty -} { [] }
302 | fix_decls ';' { $1 }
304 fix_decls :: { [RdrNameFixitySig] }
306 | fix_decl fix_decls { $1 : $2 }
308 fix_decl :: { RdrNameFixitySig }
309 fix_decl : src_loc fixity prec var_or_data_name { FixitySig $4 (Fixity $3 $2) $1 }
311 fixity :: { FixityDirection }
312 fixity : 'infixl' { InfixL }
313 | 'infixr' { InfixR }
317 prec : INTEGER { fromInteger $1 }
319 -----------------------------------------------------------------------------
321 csigs :: { [RdrNameSig] }
323 | 'where' '{' csigs1 '}' { $3 }
325 csigs1 :: { [RdrNameSig] }
327 | csig ';' csigs1 { $1 : $3 }
329 csig :: { RdrNameSig }
330 csig : src_loc qvar_name '::' type { ClassOpSig $2 NoDefMeth $4 $1 }
331 | src_loc qvar_name ';' '::' type { ClassOpSig $2 GenDefMeth $5 $1 }
332 | src_loc qvar_name '=' '::' type { mkClassOpSigDM $2 $5 $1 }
334 --------------------------------------------------------------------------
336 instance_decl_part :: { [RdrNameInstDecl] }
337 instance_decl_part : {- empty -} { [] }
338 | instance_decl_part inst_decl { $2 : $1 }
340 inst_decl :: { RdrNameInstDecl }
341 inst_decl : src_loc 'instance' type '=' qvar_name ';'
343 EmptyMonoBinds {- No bindings -}
344 [] {- No user pragmas -}
345 (Just $5) {- Dfun id -}
349 --------------------------------------------------------------------------
351 decls_part :: { [(Version, RdrNameTyClDecl)] }
354 | opt_version decl ';' decls_part { ($1,$2):$4 }
356 decl :: { RdrNameTyClDecl }
357 decl : src_loc qvar_name '::' type maybe_idinfo
358 { IfaceSig $2 $4 ($5 $2) $1 }
359 | src_loc 'type' qtc_name tv_bndrs '=' type
360 { TySynonym $3 $4 $6 $1 }
361 | src_loc 'data' opt_decl_context qtc_name tv_bndrs constrs
362 { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 }
363 | src_loc 'newtype' opt_decl_context qtc_name tv_bndrs newtype_constr
364 { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 }
365 | src_loc 'class' opt_decl_context qtc_name tv_bndrs fds csigs
366 { mkClassDecl $3 $4 $5 $6 $7 Nothing $1 }
368 maybe_idinfo :: { RdrName -> [HsIdInfo RdrName] }
369 maybe_idinfo : {- empty -} { \_ -> [] }
370 | pragma { \x -> if opt_IgnoreIfacePragmas then []
372 POk _ (PIdInfo id_info) -> id_info
373 PFailed err -> pprPanic "IdInfo parse failed"
377 If a signature decl is being loaded, and opt_IgnoreIfacePragmas is on,
378 we toss away unfolding information.
380 Also, if the signature is loaded from a module we're importing from source,
381 we do the same. This is to avoid situations when compiling a pair of mutually
382 recursive modules, peering at unfolding info in the interface file of the other,
383 e.g., you compile A, it looks at B's interface file and may as a result change
384 its interface file. Hence, B is recompiled, maybe changing its interface file,
385 which will the unfolding info used in A to become invalid. Simple way out is to
386 just ignore unfolding info.
388 [Jan 99: I junked the second test above. If we're importing from an hi-boot
389 file there isn't going to *be* any pragma info. The above comment
390 dates from a time where we picked up a .hi file first if it existed.]
393 pragma :: { ParseResult IfaceStuff }
394 pragma : src_loc PRAGMA { parseIface $2 PState{ bol = 0#, atbol = 1#,
400 -----------------------------------------------------------------------------
402 rules_and_deprecs_part :: { ([RdrNameRuleDecl], IfaceDeprecs) }
403 rules_and_deprecs_part : {- empty -} { ([], Nothing) }
404 | pragma { case $1 of
405 POk _ (PRulesAndDeprecs rds) -> rds
406 PFailed err -> pprPanic "Rules/Deprecations parse failed" err
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 rule_forall qvar_name
425 core_args '=' core_expr { IfaceRule $2 $3 $4 $5 $7 $1 }
427 rule_forall :: { [UfBinder RdrName] }
428 rule_forall : '__forall' '{' core_bndrs '}' { $3 }
430 -----------------------------------------------------------------------------
432 deprec_prag :: { IfaceDeprecs }
433 deprec_prag : {- empty -} { Nothing }
434 | '__D' deprecs { Just $2 }
436 deprecs :: { Either DeprecTxt [(RdrName,DeprecTxt)] }
437 deprecs : STRING { Left $1 }
438 | deprec_list { Right $1 }
440 deprec_list :: { [(RdrName,DeprecTxt)] }
441 deprec_list : deprec { [$1] }
442 | deprec ';' deprec_list { $1 : $3 }
444 deprec :: { (RdrName,DeprecTxt) }
445 deprec : deprec_name STRING { ($1, $2) }
447 deprec_name :: { RdrName }
451 -----------------------------------------------------------------------------
453 version :: { Version }
454 version : INTEGER { fromInteger $1 }
456 opt_version :: { Version }
457 opt_version : version { $1 }
458 | {- empty -} { initialVersion }
460 opt_decl_context :: { RdrNameContext }
461 opt_decl_context : { [] }
462 | context '=>' { $1 }
464 ----------------------------------------------------------------------------
466 constrs :: { [RdrNameConDecl] {- empty for handwritten abstract -} }
468 | '=' constrs1 { $2 }
470 constrs1 :: { [RdrNameConDecl] }
471 constrs1 : constr { [$1] }
472 | constr '|' constrs1 { $1 : $3 }
474 constr :: { RdrNameConDecl }
475 constr : src_loc ex_stuff qdata_name batypes { mk_con_decl $3 $2 (VanillaCon $4) $1 }
476 | src_loc ex_stuff qdata_name '{' fields1 '}' { mk_con_decl $3 $2 (RecCon $5) $1 }
477 -- We use "data_fs" so as to include ()
479 newtype_constr :: { [RdrNameConDecl] {- Not allowed to be empty -} }
480 newtype_constr : src_loc '=' ex_stuff qdata_name atype { [mk_con_decl $4 $3 (VanillaCon [Unbanged $5]) $1] }
481 | src_loc '=' ex_stuff qdata_name '{' qvar_name '::' atype '}'
482 { [mk_con_decl $4 $3 (RecCon [([$6], Unbanged $8)]) $1] }
484 ex_stuff :: { ([HsTyVarBndr RdrName], RdrNameContext) }
485 ex_stuff : { ([],[]) }
486 | '__forall' tv_bndrs opt_context '=>' { ($2,$3) }
488 batypes :: { [RdrNameBangType] }
490 | batype batypes { $1 : $2 }
492 batype :: { RdrNameBangType }
493 batype : tatype { Unbanged $1 }
494 | '!' tatype { Banged $2 }
495 | '!' '!' tatype { Unpacked $3 }
497 fields1 :: { [([RdrName], RdrNameBangType)] }
498 fields1 : field { [$1] }
499 | field ',' fields1 { $1 : $3 }
501 field :: { ([RdrName], RdrNameBangType) }
502 field : qvar_names1 '::' ttype { ($1, Unbanged $3) }
503 | qvar_names1 '::' '!' ttype { ($1, Banged $4) }
504 | qvar_names1 '::' '!' '!' ttype { ($1, Unpacked $5) }
506 --------------------------------------------------------------------------
508 type :: { RdrNameHsType }
509 type : '__forall' tv_bndrs
510 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
511 | btype '->' type { HsFunTy $1 $3 }
514 opt_context :: { RdrNameContext }
518 context :: { RdrNameContext }
519 context : '(' context_list1 ')' { $2 }
520 | '{' context_list1 '}' { $2 } -- Backward compatibility
522 context_list1 :: { RdrNameContext }
523 context_list1 : class { [$1] }
524 | class ',' context_list1 { $1 : $3 }
526 class :: { HsPred RdrName }
527 class : qcls_name atypes { (HsPClass $1 $2) }
528 | ipvar_name '::' type { (HsPIParam $1 $3) }
530 types0 :: { [RdrNameHsType] {- Zero or more -} }
531 types0 : {- empty -} { [ ] }
535 types2 :: { [RdrNameHsType] {- Two or more -} }
536 types2 : type ',' type { [$1,$3] }
537 | type ',' types2 { $1 : $3 }
539 btype :: { RdrNameHsType }
541 | btype atype { HsAppTy $1 $2 }
542 | '__u' atype atype { HsUsageTy $2 $3 }
544 atype :: { RdrNameHsType }
545 atype : qtc_name { HsTyVar $1 }
546 | tv_name { HsTyVar $1 }
549 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
550 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
551 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
552 | '[' type ']' { HsListTy $2 }
553 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
554 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
555 | '(' type ')' { $2 }
557 atypes :: { [RdrNameHsType] {- Zero or more -} }
559 | atype atypes { $1 : $2 }
560 --------------------------------------------------------------------------
562 -- versions of type/btype/atype that cant begin with '!' (or '.')
563 -- for use where the kind is definitely known NOT to be '$'
565 ttype :: { RdrNameHsType }
566 ttype : '__forall' tv_bndrs
567 opt_context '=>' type { mkHsForAllTy (Just $2) $3 $5 }
568 | tbtype '->' type { HsFunTy $1 $3 }
571 tbtype :: { RdrNameHsType }
572 tbtype : tatype { $1 }
573 | tbtype atype { HsAppTy $1 $2 }
574 | '__u' atype atype { HsUsageTy $2 $3 }
576 tatype :: { RdrNameHsType }
577 tatype : qtc_name { HsTyVar $1 }
578 | tv_name { HsTyVar $1 }
579 | '(' ')' { HsTupleTy (mkHsTupCon tcName Boxed []) [] }
580 | '(' types2 ')' { HsTupleTy (mkHsTupCon tcName Boxed $2) $2 }
581 | '(#' types0 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
582 | '[' type ']' { HsListTy $2 }
583 | '{' qcls_name atypes '}' { mkHsDictTy $2 $3 }
584 | '{' ipvar_name '::' type '}' { mkHsIParamTy $2 $4 }
585 | '(' type ')' { $2 }
586 ---------------------------------------------------------------------
588 package :: { PackageName }
590 | {- empty -} { opt_InPackage } -- Useful for .hi-boot files,
591 -- which can omit the package Id
592 -- Module loops are always within a package
594 mod_name :: { ModuleName }
595 : CONID { mkSysModuleNameFS $1 }
598 ---------------------------------------------------
599 var_fs :: { EncodedFS }
602 | 'as' { SLIT("as") }
603 | 'qualified' { SLIT("qualified") }
604 | 'hiding' { SLIT("hiding") }
605 | 'forall' { SLIT("forall") }
606 | 'foreign' { SLIT("foreign") }
607 | 'export' { SLIT("export") }
608 | 'label' { SLIT("label") }
609 | 'dynamic' { SLIT("dynamic") }
610 | 'unsafe' { SLIT("unsafe") }
611 | 'with' { SLIT("with") }
612 | 'ccall' { SLIT("ccall") }
613 | 'stdcall' { SLIT("stdcall") }
615 qvar_fs :: { (EncodedFS, EncodedFS) }
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 | qvar_fs { mkIfaceOrig varName $1 }
629 ipvar_name :: { RdrName }
630 : IPVARID { mkRdrUnqual (mkSysOccFS ipName (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 ---------------------------------------------------
644 -- For some bizarre reason,
645 -- (,,,) is dealt with by the parser
646 -- Foo.(,,,) is dealt with by the lexer
649 data_fs :: { EncodedFS }
653 qdata_fs :: { (EncodedFS, EncodedFS) }
657 data_occ :: { OccName }
658 : data_fs { mkSysOccFS dataName $1 }
660 data_name :: { RdrName }
661 : data_occ { mkRdrUnqual $1 }
663 qdata_name :: { RdrName }
664 qdata_name : data_name { $1 }
665 | qdata_fs { mkIfaceOrig dataName $1 }
667 var_or_data_name :: { RdrName }
671 ---------------------------------------------------
672 tc_occ :: { OccName }
673 : data_fs { mkSysOccFS tcName $1 }
675 tc_name :: { RdrName }
676 : tc_occ { mkRdrUnqual $1 }
678 qtc_name :: { RdrName }
680 | qdata_fs { mkIfaceOrig tcName $1 }
682 ---------------------------------------------------
683 cls_name :: { RdrName }
684 : data_fs { mkRdrUnqual (mkSysOccFS clsName $1) }
686 qcls_name :: { RdrName }
688 | qdata_fs { mkIfaceOrig clsName $1 }
690 ---------------------------------------------------
691 tv_name :: { RdrName }
692 : VARID { mkRdrUnqual (mkSysOccFS tvName $1) }
694 tv_bndr :: { HsTyVarBndr RdrName }
695 : tv_name '::' akind { IfaceTyVar $1 $3 }
696 | tv_name { IfaceTyVar $1 boxedTypeKind }
698 tv_bndrs :: { [HsTyVarBndr RdrName] }
700 | '[' tv_bndrs1 ']' { $2 } -- Backward compatibility
702 tv_bndrs1 :: { [HsTyVarBndr RdrName] }
704 | tv_bndr tv_bndrs1 { $1 : $2 }
706 ---------------------------------------------------
707 fds :: { [([RdrName], [RdrName])] }
709 | '|' fds1 { reverse $2 }
711 fds1 :: { [([RdrName], [RdrName])] }
712 : fds1 ',' fd { $3 : $1 }
715 fd :: { ([RdrName], [RdrName]) }
716 : varids0 '->' varids0 { (reverse $1, reverse $3) }
718 varids0 :: { [RdrName] }
720 | varids0 tv_name { $2 : $1 }
722 ---------------------------------------------------
725 | akind '->' kind { mkArrowKind $1 $3 }
728 : VARSYM { if $1 == SLIT("*") then
730 else if $1 == SLIT("?") then
732 else if $1 == SLIT("\36") then
733 usageTypeKind -- dollar
734 else panic "ParseInterface: akind"
736 | '(' kind ')' { $2 }
738 --------------------------------------------------------------------------
740 id_info :: { [HsIdInfo RdrName] }
741 : id_info_item { [$1] }
742 | id_info_item id_info { $1 : $2 }
744 id_info_item :: { HsIdInfo RdrName }
745 : '__A' INTEGER { HsArity (exactArity (fromInteger $2)) }
746 | '__U' inline_prag core_expr { HsUnfold $2 $3 }
747 | '__M' { HsCprInfo }
748 | '__S' { HsStrictness (mkStrictnessInfo $1) }
749 | '__C' { HsNoCafRefs }
750 | '__P' qvar_name { HsWorker $2 }
752 inline_prag :: { InlinePragInfo }
753 : {- empty -} { NoInlinePragInfo }
754 | '[' from_prag phase ']' { IMustNotBeINLINEd $2 $3 }
756 from_prag :: { Bool }
757 : {- empty -} { True }
760 phase :: { Maybe Int }
761 : {- empty -} { Nothing }
762 | INTEGER { Just (fromInteger $1) }
764 -------------------------------------------------------
765 core_expr :: { UfExpr RdrName }
766 core_expr : '\\' core_bndrs '->' core_expr { foldr UfLam $4 $2 }
767 | 'case' core_expr 'of' var_name
768 '{' core_alts '}' { UfCase $2 $4 $6 }
770 | 'let' '{' core_val_bndr '=' core_expr
771 '}' 'in' core_expr { UfLet (UfNonRec $3 $5) $8 }
772 | '__letrec' '{' rec_binds '}'
773 'in' core_expr { UfLet (UfRec $3) $6 }
775 | '__litlit' STRING atype { UfLitLit $2 $3 }
779 fexpr :: { UfExpr RdrName }
780 fexpr : fexpr core_arg { UfApp $1 $2 }
781 | scc core_aexpr { UfNote (UfSCC $1) $2 }
782 | '__inline_me' core_aexpr { UfNote UfInlineMe $2 }
783 | '__inline_call' core_aexpr { UfNote UfInlineCall $2 }
784 | '__coerce' atype core_aexpr { UfNote (UfCoerce $2) $3 }
787 core_arg :: { UfExpr RdrName }
788 : '@' atype { UfType $2 }
791 core_args :: { [UfExpr RdrName] }
793 | core_arg core_args { $1 : $2 }
795 core_aexpr :: { UfExpr RdrName } -- Atomic expressions
796 core_aexpr : qvar_name { UfVar $1 }
797 | qdata_name { UfVar $1 }
799 | core_lit { UfLit $1 }
800 | '(' core_expr ')' { $2 }
802 | '(' ')' { UfTuple (mkHsTupCon dataName Boxed []) [] }
803 | '(' comma_exprs2 ')' { UfTuple (mkHsTupCon dataName Boxed $2) $2 }
804 | '(#' comma_exprs0 '#)' { UfTuple (mkHsTupCon dataName Unboxed $2) $2 }
806 | '{' '__ccall' ccall_string type '}'
808 (is_dyn, is_casm, may_gc) = $2
810 target | is_dyn = DynamicTarget (error "CCall dyn target bogus unique")
811 | otherwise = StaticTarget $3
813 ccall = CCall target is_casm may_gc cCallConv
819 comma_exprs0 :: { [UfExpr RdrName] } -- Zero or more
820 comma_exprs0 : {- empty -} { [ ] }
821 | core_expr { [ $1 ] }
822 | comma_exprs2 { $1 }
824 comma_exprs2 :: { [UfExpr RdrName] } -- Two or more
825 comma_exprs2 : core_expr ',' core_expr { [$1,$3] }
826 | core_expr ',' comma_exprs2 { $1 : $3 }
828 rec_binds :: { [(UfBinder RdrName, UfExpr RdrName)] }
830 | core_val_bndr '=' core_expr ';' rec_binds { ($1,$3) : $5 }
832 core_alts :: { [UfAlt RdrName] }
834 | core_alt ';' core_alts { $1 : $3 }
836 core_alt :: { UfAlt RdrName }
837 core_alt : core_pat '->' core_expr { (fst $1, snd $1, $3) }
839 core_pat :: { (UfConAlt RdrName, [RdrName]) }
840 core_pat : core_lit { (UfLitAlt $1, []) }
841 | '__litlit' STRING atype { (UfLitLitAlt $2 $3, []) }
842 | qdata_name core_pat_names { (UfDataAlt $1, $2) }
843 | '(' ')' { (UfTupleAlt (mkHsTupCon dataName Boxed []), []) }
844 | '(' comma_var_names1 ')' { (UfTupleAlt (mkHsTupCon dataName Boxed $2), $2) }
845 | '(#' comma_var_names1 '#)' { (UfTupleAlt (mkHsTupCon dataName Unboxed $2), $2) }
846 | '__DEFAULT' { (UfDefault, []) }
847 | '(' core_pat ')' { $2 }
849 core_pat_names :: { [RdrName] }
850 core_pat_names : { [] }
851 | core_pat_name core_pat_names { $1 : $2 }
853 -- Tyvar names and variable names live in different name spaces
854 -- so they need to be signalled separately. But we don't record
855 -- types or kinds in a pattern; we work that out from the type
856 -- of the case scrutinee
857 core_pat_name :: { RdrName }
858 core_pat_name : var_name { $1 }
861 comma_var_names1 :: { [RdrName] } -- One or more
862 comma_var_names1 : var_name { [$1] }
863 | var_name ',' comma_var_names1 { $1 : $3 }
865 core_lit :: { Literal }
866 core_lit : integer { mkMachInt $1 }
867 | CHAR { MachChar $1 }
868 | STRING { MachStr $1 }
869 | rational { MachDouble $1 }
870 | '__word' integer { mkMachWord $2 }
871 | '__word64' integer { mkMachWord64 $2 }
872 | '__int64' integer { mkMachInt64 $2 }
873 | '__float' rational { MachFloat $2 }
874 | '__addr' integer { MachAddr $2 }
875 | '__label' STRING { MachLabel $2 }
877 integer :: { Integer }
879 | '-' INTEGER { (-$2) }
881 rational :: { Rational }
883 | '-' RATIONAL { (-$2) }
885 core_bndr :: { UfBinder RdrName }
886 core_bndr : core_val_bndr { $1 }
887 | core_tv_bndr { $1 }
889 core_bndrs :: { [UfBinder RdrName] }
891 | core_bndr core_bndrs { $1 : $2 }
893 core_val_bndr :: { UfBinder RdrName }
894 core_val_bndr : var_name '::' atype { UfValBinder $1 $3 }
896 core_tv_bndr :: { UfBinder RdrName }
897 core_tv_bndr : '@' tv_name '::' akind { UfTyBinder $2 $4 }
898 | '@' tv_name { UfTyBinder $2 boxedTypeKind }
900 ccall_string :: { FAST_STRING }
906 ------------------------------------------------------------------------
907 scc :: { CostCentre }
908 : '__sccC' '{' mod_name '}' { AllCafsCC $3 }
909 | '__scc' '{' cc_name mod_name cc_dup cc_caf '}'
910 { NormalCC { cc_name = $3, cc_mod = $4,
911 cc_is_dupd = $5, cc_is_caf = $6 } }
913 cc_name :: { EncodedFS }
917 cc_dup :: { IsDupdCC }
918 cc_dup : { OriginalCC }
921 cc_caf :: { IsCafCC }
925 -------------------------------------------------------------------
927 src_loc :: { SrcLoc }
928 src_loc : {% getSrcLocP }
930 -- Check the project version: this makes sure
931 -- that the project version (e.g. 407) in the interface
932 -- file is the same as that for the compiler that's reading it
933 checkVersion :: { () }
934 : {-empty-} {% checkVersion Nothing }
935 | INTEGER {% checkVersion (Just (fromInteger $1)) }
937 -------------------------------------------------------------------
942 happyError buf PState{ loc = loc } = PFailed (ifaceParseErr buf loc)
944 data IfaceStuff = PIface ParsedIface
945 | PIdInfo [HsIdInfo RdrName]
946 | PType RdrNameHsType
947 | PRulesAndDeprecs ([RdrNameRuleDecl], IfaceDeprecs)
949 mk_con_decl name (ex_tvs, ex_ctxt) details loc = mkConDecl name ex_tvs ex_ctxt details loc