ghc/compiler/rename/ParseIface.y

   1 {-      Notes about the syntax of interface files
   2         ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   3 The header
   4 ~~~~~~~~~~
   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
   9
  10 Import declarations
  11 ~~~~~~~~~~~~~~~~~~~
  12   import Foo ;                          To compile M I used nothing from Foo, but it's
  13                                         below me in the hierarchy
  14
  15   import Foo ! @ ;                      Ditto, but the ! means that Foo contains orphans
  16                                         and        the @ means that Foo is a boot interface
  17
  18   import Foo :: 3 ;                     To compile M I used everything from Foo, which has
  19                                         module version 3
  20
  21   import Foo :: 3 2 6 a 1 b 3 c 7 ;     To compile M I used Foo.  It had
  22                                                 module version 3
  23                                                 fixity version 2
  24                                                 rules  version 6
  25                                         and some specific things besides.
  26
  27 -}
  28
  29
  30 {
  31 module ParseIface ( parseIface, parseType, parseRules, parseIdInfo ) where
  32
  33 #include "HsVersions.h"
  34
  35 import HsSyn            -- quite a bit of stuff
  36 import RdrHsSyn         -- oodles of synonyms
  37 import HsTypes          ( mkHsForAllTy, mkHsTupCon )
  38 import HsCore
  39 import Literal          ( Literal(..), mkMachInt, mkMachInt64, mkMachWord, mkMachWord64 )
  40 import BasicTypes       ( Fixity(..), FixityDirection(..), StrictnessMark(..),
  41                           NewOrData(..), Version, initialVersion, Boxity(..),
  42                           Activation(..), IPName(..)
  43                         )
  44 import CostCentre       ( CostCentre(..), IsCafCC(..), IsDupdCC(..) )
  45 import Type             ( Kind, mkArrowKind, liftedTypeKind, openTypeKind, usageTypeKind )
  46 import ForeignCall      ( ForeignCall(..), CCallConv(..), CCallSpec(..), CCallTarget(..) )
  47 import Lex
  48
  49 import RnMonad          ( ParsedIface(..), ExportItem, IfaceDeprecs )
  50 import HscTypes         ( WhetherHasOrphans, IsBootInterface, GenAvailInfo(..),
  51                           ImportVersion, WhatsImported(..),
  52                           RdrAvailInfo )
  53
  54 import RdrName          ( RdrName, mkRdrUnqual, mkIfaceOrig )
  55 import Name             ( OccName )
  56 import OccName          ( mkSysOccFS,
  57                           tcName, varName, dataName, clsName, tvName,
  58                           EncodedFS
  59                         )
  60 import Module           ( ModuleName, PackageName, mkSysModuleNameFS )
  61 import SrcLoc           ( SrcLoc )
  62 import CmdLineOpts      ( opt_InPackage, opt_IgnoreIfacePragmas )
  63 import Outputable
  64 import Class            ( DefMeth (..) )
  65
  66 import GlaExts
  67 import FastString       ( tailFS )
  68 }
  69
  70 %name       parseIface      iface
  71 %name       parseType       type
  72 %name       parseIdInfo     id_info
  73 %name       parseRules      rules_and_deprecs
  74
  75 %tokentype  { Token }
  76 %monad      { P }{ thenP }{ returnP }
  77 %lexer      { lexer } { ITeof }
  78
  79 %token
  80  'as'           { ITas }
  81  'case'         { ITcase }                      -- Haskell keywords
  82  'class'        { ITclass }
  83  'data'         { ITdata }
  84  'default'      { ITdefault }
  85  'deriving'     { ITderiving }
  86  'do'           { ITdo }
  87  'else'         { ITelse }
  88  'hiding'       { IThiding }
  89  'if'           { ITif }
  90  'import'       { ITimport }
  91  'in'           { ITin }
  92  'infix'        { ITinfix }
  93  'infixl'       { ITinfixl }
  94  'infixr'       { ITinfixr }
  95  'instance'     { ITinstance }
  96  'let'          { ITlet }
  97  'module'       { ITmodule }
  98  'newtype'      { ITnewtype }
  99  'of'           { ITof }
 100  'qualified'    { ITqualified }
 101  'then'         { ITthen }
 102  'type'         { ITtype }
 103  'where'        { ITwhere }
 104
 105  'forall'       { ITforall }                    -- GHC extension keywords
 106  'foreign'      { ITforeign }
 107  'export'       { ITexport }
 108  'label'        { ITlabel }
 109  'dynamic'      { ITdynamic }
 110  'unsafe'       { ITunsafe }
 111  'with'         { ITwith }
 112  'stdcall'      { ITstdcallconv }
 113  'ccall'        { ITccallconv }
 114
 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 }
 124  '__bot'        { ITbottom }
 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 $$ }
 136  '__scc'        { ITscc }
 137  '__sccC'       { ITsccAllCafs }
 138
 139  '__u'          { ITusage }
 140
 141  '__A'          { ITarity }
 142  '__P'          { ITspecialise }
 143  '__C'          { ITnocaf }
 144  '__U'          { ITunfold }
 145  '__S'          { ITstrict $$ }
 146  '__R'          { ITrules }
 147  '__M'          { ITcprinfo }
 148  '__D'          { ITdeprecated }
 149
 150  '..'           { ITdotdot }                    -- reserved symbols
 151  '::'           { ITdcolon }
 152  '='            { ITequal }
 153  '\\'           { ITlam }
 154  '|'            { ITvbar }
 155  '<-'           { ITlarrow }
 156  '->'           { ITrarrow }
 157  '@'            { ITat }
 158  '~'            { ITtilde }
 159  '=>'           { ITdarrow }
 160  '-'            { ITminus }
 161  '!'            { ITbang }
 162
 163  '{'            { ITocurly }                    -- special symbols
 164  '}'            { ITccurly }
 165  '{|'           { ITocurlybar }                         -- special symbols
 166  '|}'           { ITccurlybar }                         -- special symbols
 167  '['            { ITobrack }
 168  ']'            { ITcbrack }
 169  '('            { IToparen }
 170  ')'            { ITcparen }
 171  '(#'           { IToubxparen }
 172  '#)'           { ITcubxparen }
 173  ';'            { ITsemi }
 174  ','            { ITcomma }
 175  '.'            { ITdot }
 176
 177  VARID          { ITvarid    $$ }               -- identifiers
 178  CONID          { ITconid    $$ }
 179  VARSYM         { ITvarsym   $$ }
 180  CONSYM         { ITconsym   $$ }
 181  QVARID         { ITqvarid   $$ }
 182  QCONID         { ITqconid   $$ }
 183  QVARSYM        { ITqvarsym  $$ }
 184  QCONSYM        { ITqconsym  $$ }
 185
 186  IPDUPVARID     { ITdupipvarid   $$ }           -- GHC extension
 187  IPSPLITVARID   { ITsplitipvarid $$ }           -- GHC extension
 188
 189  PRAGMA         { ITpragma   $$ }
 190
 191  CHAR           { ITchar     $$ }
 192  STRING         { ITstring   $$ }
 193  INTEGER        { ITinteger  $$ }
 194  RATIONAL       { ITrational $$ }
 195  CLITLIT        { ITlitlit   $$ }
 196
 197  UNKNOWN        { ITunknown  $$ }
 198 %%
 199
 200 iface           :: { ParsedIface }
 201 iface           : '__interface' package mod_name
 202                         version sub_versions
 203                         orphans checkVersion 'where'
 204                   exports_part
 205                   import_part
 206                   fix_decl_part
 207                   instance_decl_part
 208                   decls_part
 209                   rules_and_deprecs_part
 210                   { let (rules,deprecs) = $14 () in
 211                     ParsedIface {
 212                         pi_mod  = $3,                   -- Module name
 213                         pi_pkg = $2,                    -- Package name
 214                         pi_vers = $4,                   -- Module version
 215                         pi_orphan  = $6,
 216                         pi_exports = (fst $5, $9),      -- Exports
 217                         pi_usages  = $10,               -- Usages
 218                         pi_fixity  = $11,               -- Fixies
 219                         pi_insts   = $12,               -- Local instances
 220                         pi_decls   = $13,               -- Decls
 221                         pi_rules   = (snd $5,rules),    -- Rules
 222                         pi_deprecs = deprecs            -- Deprecations
 223                    } }
 224
 225 -- Versions for exports and rules (optional)
 226 sub_versions :: { (Version,Version) }
 227         : '[' version version ']'               { ($2,$3) }
 228         | {- empty -}                           { (initialVersion, initialVersion) }
 229
 230 --------------------------------------------------------------------------
 231
 232 import_part :: { [ImportVersion OccName] }
 233 import_part :                                             { [] }
 234             |  import_decl import_part                    { $1 : $2 }
 235
 236 import_decl :: { ImportVersion OccName }
 237 import_decl : 'import' mod_name orphans is_boot whats_imported ';'
 238                         { ({-mkSysModuleNameFS-} $2, $3, $4, $5) }
 239
 240 orphans             :: { WhetherHasOrphans }
 241 orphans             :                                           { False }
 242                     | '!'                                       { True }
 243
 244 is_boot             :: { IsBootInterface }
 245 is_boot             :                                           { False }
 246                     | '@'                                       { True }
 247
 248 whats_imported      :: { WhatsImported OccName }
 249 whats_imported      :                                                   { NothingAtAll }
 250                     | '::' version                                      { Everything $2 }
 251                     | '::' version version version name_version_pairs   { Specifically $2 (Just $3) $5 $4 }
 252                     | '::' version version name_version_pairs           { Specifically $2 Nothing $4 $3 }
 253
 254 name_version_pairs  ::  { [(OccName, Version)] }
 255 name_version_pairs  :                                           { [] }
 256                     |  name_version_pair name_version_pairs     { $1 : $2 }
 257
 258 name_version_pair   ::  { (OccName, Version) }
 259 name_version_pair   :  var_occ version                          { ($1, $2) }
 260                     |  tc_occ  version                          { ($1, $2) }
 261
 262
 263 --------------------------------------------------------------------------
 264
 265 exports_part    :: { [ExportItem] }
 266 exports_part    :                                       { [] }
 267                 | '__export' mod_name entities ';'
 268                         exports_part                    { ({-mkSysModuleNameFS-} $2, $3) : $5 }
 269
 270 entities        :: { [RdrAvailInfo] }
 271 entities        :                                       { [] }
 272                 |  entity entities                      { $1 : $2 }
 273
 274 entity          :: { RdrAvailInfo }
 275 entity          :  var_occ                              { Avail $1 }
 276                 |  tc_occ                               { AvailTC $1 [$1] }
 277                 |  tc_occ '|' stuff_inside              { AvailTC $1 $3 }
 278                 |  tc_occ stuff_inside                  { AvailTC $1 ($1:$2) }
 279                 -- Note that the "main name" comes at the beginning
 280
 281 stuff_inside    :: { [OccName] }
 282 stuff_inside    :  '{' val_occs '}'                     { $2 }
 283
 284 val_occ         :: { OccName }
 285                 :  var_occ              { $1 }
 286                 |  data_occ             { $1 }
 287
 288 val_occs        :: { [OccName] }
 289                 :  val_occ              { [$1] }
 290                 |  val_occ val_occs     { $1 : $2 }
 291
 292
 293 --------------------------------------------------------------------------
 294
 295 fix_decl_part :: { [RdrNameFixitySig] }
 296 fix_decl_part : {- empty -}                             { [] }
 297               | fix_decls ';'                           { $1 }
 298
 299 fix_decls     :: { [RdrNameFixitySig] }
 300 fix_decls     :                                         { [] }
 301               | fix_decl fix_decls                      { $1 : $2 }
 302
 303 fix_decl :: { RdrNameFixitySig }
 304 fix_decl : src_loc fixity prec var_or_data_name         { FixitySig $4 (Fixity $3 $2) $1 }
 305
 306 fixity      :: { FixityDirection }
 307 fixity      : 'infixl'                                  { InfixL }
 308             | 'infixr'                                  { InfixR }
 309             | 'infix'                                   { InfixN }
 310
 311 prec        :: { Int }
 312 prec        : INTEGER                                   { fromInteger $1 }
 313
 314 -----------------------------------------------------------------------------
 315
 316 csigs           :: { [RdrNameSig] }
 317 csigs           :                               { [] }
 318                 | 'where' '{' csigs1 '}'        { $3 }
 319
 320 csigs1          :: { [RdrNameSig] }
 321 csigs1          :                               { [] }
 322                 | csig ';' csigs1               { $1 : $3 }
 323
 324 csig            :: { RdrNameSig }
 325 csig            :  src_loc qvar_name '::' type          { ClassOpSig $2 NoDefMeth $4 $1 }
 326                 |  src_loc qvar_name ';' '::' type      { ClassOpSig $2 GenDefMeth $5 $1 }
 327                 |  src_loc qvar_name '=' '::' type      { mkClassOpSigDM $2 $5 $1 }
 328
 329 --------------------------------------------------------------------------
 330
 331 instance_decl_part :: { [RdrNameInstDecl] }
 332 instance_decl_part : {- empty -}                       { [] }
 333                    | instance_decl_part inst_decl      { $2 : $1 }
 334
 335 inst_decl       :: { RdrNameInstDecl }
 336 inst_decl       :  src_loc 'instance' type '=' qvar_name ';'
 337                         { InstDecl $3
 338                                    EmptyMonoBinds       {- No bindings -}
 339                                    []                   {- No user pragmas -}
 340                                    (Just $5)            {- Dfun id -}
 341                                    $1
 342                         }
 343
 344 --------------------------------------------------------------------------
 345
 346 decls_part :: { [(Version, RdrNameTyClDecl)] }
 347 decls_part
 348         :  {- empty -}                          { [] }
 349         |  opt_version decl ';' decls_part              { ($1,$2):$4 }
 350
 351 decl    :: { RdrNameTyClDecl }
 352 decl    : src_loc qvar_name '::' type maybe_idinfo
 353                         { IfaceSig $2 $4 ($5 $2) $1 }
 354         | src_loc 'type' qtc_name tv_bndrs '=' type
 355                         { TySynonym $3 $4 $6 $1 }
 356         | src_loc 'foreign' 'type' qtc_name
 357                         { ForeignType $4 Nothing DNType $1 }
 358         | src_loc 'data' opt_decl_context qtc_name tv_bndrs constrs
 359                         { mkTyData DataType $3 $4 $5 $6 (length $6) Nothing $1 }
 360         | src_loc 'newtype' opt_decl_context qtc_name tv_bndrs newtype_constr
 361                         { mkTyData NewType $3 $4 $5 $6 1 Nothing $1 }
 362         | src_loc 'class' opt_decl_context qtc_name tv_bndrs fds csigs
 363                         { mkClassDecl $3 $4 $5 $6 $7 Nothing $1 }
 364
 365 maybe_idinfo  :: { RdrName -> [HsIdInfo RdrName] }
 366 maybe_idinfo  : {- empty -}     { \_ -> [] }
 367               | pragma          { \x -> if opt_IgnoreIfacePragmas then []
 368                                         else case $1 of
 369                                                 Just (POk _ id_info) -> id_info
 370                                                 Just (PFailed err) -> pprPanic "IdInfo parse failed"
 371                                                                         (vcat [ppr x, err])
 372                                 }
 373     {-
 374       If a signature decl is being loaded, and opt_IgnoreIfacePragmas is on,
 375       we toss away unfolding information.
 376
 377       Also, if the signature is loaded from a module we're importing from source,
 378       we do the same. This is to avoid situations when compiling a pair of mutually
 379       recursive modules, peering at unfolding info in the interface file of the other,
 380       e.g., you compile A, it looks at B's interface file and may as a result change
 381       its interface file. Hence, B is recompiled, maybe changing its interface file,
 382       which will the unfolding info used in A to become invalid. Simple way out is to
 383       just ignore unfolding info.
 384
 385       [Jan 99: I junked the second test above.  If we're importing from an hi-boot
 386        file there isn't going to *be* any pragma info.  The above comment
 387        dates from a time where we picked up a .hi file first if it existed.]
 388     -}
 389
 390 pragma  :: { Maybe (ParseResult [HsIdInfo RdrName]) }
 391 pragma  : src_loc PRAGMA        { Just (parseIdInfo $2 PState{ bol = 0#, atbol = 1#,
 392                                                         context = [],
 393                                                         glasgow_exts = 1#,
 394                                                         loc = $1 })
 395                                 }
 396
 397 -----------------------------------------------------------------------------
 398
 399 -- This production is lifted so that it doesn't get eagerly parsed when we
 400 -- use happy --strict.
 401 rules_and_deprecs_part :: { () -> ([RdrNameRuleDecl], IfaceDeprecs) }
 402 rules_and_deprecs_part
 403   : {- empty -}         { \_ -> ([], Nothing) }
 404   | src_loc PRAGMA      { \_ -> case parseRules $2 PState{ bol = 0#, atbol = 1#,
 405                                                            context = [],
 406                                                            glasgow_exts = 1#,
 407                                                            loc = $1 } of
 408                                         POk _ rds   -> rds
 409                                         PFailed err -> pprPanic "Rules/Deprecations parse failed" err
 410                         }
 411
 412 rules_and_deprecs :: { ([RdrNameRuleDecl], IfaceDeprecs) }
 413 rules_and_deprecs : rule_prag deprec_prag       { ($1, $2) }
 414
 415
 416 -----------------------------------------------------------------------------
 417
 418 rule_prag :: { [RdrNameRuleDecl] }
 419 rule_prag : {- empty -}                 { [] }
 420           | '__R' rules                 { $2 }
 421
 422 rules      :: { [RdrNameRuleDecl] }
 423            : {- empty -}        { [] }
 424            | rule ';' rules     { $1:$3 }
 425
 426 rule       :: { RdrNameRuleDecl }
 427 rule       : src_loc STRING activation rule_forall qvar_name
 428              core_args '=' core_expr    { IfaceRule $2 $3 $4 $5 $6 $8 $1 }
 429
 430 activation :: { Activation }
 431 activation : {- empty -}                { AlwaysActive }
 432            | '[' INTEGER ']'            { ActiveAfter (fromInteger $2) }
 433            | '[' '~' INTEGER ']'        { ActiveBefore (fromInteger $3) }
 434
 435 rule_forall     :: { [UfBinder RdrName] }
 436 rule_forall     : '__forall' '{' core_bndrs '}' { $3 }
 437
 438 -----------------------------------------------------------------------------
 439
 440 deprec_prag     :: { IfaceDeprecs }
 441 deprec_prag     : {- empty -}           { Nothing }
 442                 | '__D' deprecs         { Just $2 }
 443
 444 deprecs         :: { Either DeprecTxt [(RdrName,DeprecTxt)] }
 445 deprecs         : STRING                { Left $1 }
 446                 | deprec_list           { Right $1 }
 447
 448 deprec_list     :: { [(RdrName,DeprecTxt)] }
 449 deprec_list     : deprec                        { [$1] }
 450                 | deprec ';' deprec_list        { $1 : $3 }
 451
 452 deprec          :: { (RdrName,DeprecTxt) }
 453 deprec          : deprec_name STRING    { ($1, $2) }
 454
 455 deprec_name     :: { RdrName }
 456                 : qvar_name             { $1 }
 457                 | qtc_name              { $1 }
 458
 459 -----------------------------------------------------------------------------
 460
 461 version         :: { Version }
 462 version         :  INTEGER                      { fromInteger $1 }
 463
 464 opt_version     :: { Version }
 465 opt_version     : version                       { $1 }
 466                 | {- empty -}                   { initialVersion }
 467
 468 opt_decl_context  :: { RdrNameContext }
 469 opt_decl_context  :                             { [] }
 470                   | context '=>'                { $1 }
 471
 472 ----------------------------------------------------------------------------
 473
 474 constrs         :: { [RdrNameConDecl] {- empty for handwritten abstract -} }
 475                 :                       { [] }
 476                 | '=' constrs1          { $2 }
 477
 478 constrs1        :: { [RdrNameConDecl] }
 479 constrs1        :  constr               { [$1] }
 480                 |  constr '|' constrs1  { $1 : $3 }
 481
 482 constr          :: { RdrNameConDecl }
 483 constr          :  src_loc ex_stuff qdata_name batypes          { mk_con_decl $3 $2 (VanillaCon $4) $1 }
 484                 |  src_loc ex_stuff qdata_name '{' fields1 '}'  { mk_con_decl $3 $2 (RecCon $5)     $1 }
 485                 -- We use "data_fs" so as to include ()
 486
 487 newtype_constr  :: { [RdrNameConDecl] {- Not allowed to be empty -} }
 488 newtype_constr  : src_loc '=' ex_stuff qdata_name atype { [mk_con_decl $4 $3 (VanillaCon [unbangedType $5]) $1] }
 489                 | src_loc '=' ex_stuff qdata_name '{' qvar_name '::' atype '}'
 490                                                         { [mk_con_decl $4 $3 (RecCon [([$6], unbangedType $8)]) $1] }
 491
 492 ex_stuff :: { ([HsTyVarBndr RdrName], RdrNameContext) }
 493 ex_stuff        :                                       { ([],[]) }
 494                 | '__forall' tv_bndrs opt_context '=>'  { ($2,$3) }
 495
 496 batypes         :: { [RdrNameBangType] }
 497 batypes         :                                       { [] }
 498                 |  batype batypes                       { $1 : $2 }
 499
 500 batype          :: { RdrNameBangType }
 501 batype          :  tatype                               { unbangedType $1 }
 502                 |  '!' tatype                           { BangType MarkedStrict    $2 }
 503                 |  '!' '!' tatype                       { BangType MarkedUnboxed   $3 }
 504
 505 fields1         :: { [([RdrName], RdrNameBangType)] }
 506 fields1         : field                                 { [$1] }
 507                 | field ',' fields1                     { $1 : $3 }
 508
 509 field           :: { ([RdrName], RdrNameBangType) }
 510 field           :  qvar_names1 '::' ttype               { ($1, unbangedType $3) }
 511                 |  qvar_names1 '::' '!' ttype           { ($1, BangType MarkedStrict    $4) }
 512                 |  qvar_names1 '::' '!' '!' ttype       { ($1, BangType MarkedUnboxed   $5) }
 513
 514 --------------------------------------------------------------------------
 515
 516 type            :: { RdrNameHsType }
 517 type            : '__forall' tv_bndrs
 518                         opt_context '=>' type   { mkHsForAllTy (Just $2) $3 $5 }
 519                 | btype '->' type               { HsFunTy $1 $3 }
 520                 | btype                         { $1 }
 521
 522 opt_context     :: { RdrNameContext }
 523 opt_context     :                                       { [] }
 524                 | context                               { $1 }
 525
 526 context         :: { RdrNameContext }
 527 context         : '(' context_list1 ')'                 { $2 }
 528                 | '{' context_list1 '}'                 { $2 }  -- Backward compatibility
 529
 530 context_list1   :: { RdrNameContext }
 531 context_list1   : class                                 { [$1] }
 532                 | class ',' context_list1               { $1 : $3 }
 533
 534 class           :: { HsPred RdrName }
 535 class           :  qcls_name atypes                     { (HsClassP $1 $2) }
 536                 |  ipvar_name '::' type                 { (HsIParam $1 $3) }
 537
 538 types0          :: { [RdrNameHsType]                    {- Zero or more -}  }
 539 types0          :  {- empty -}                          { [ ] }
 540                 |  type                                 { [ $1 ] }
 541                 |  types2                               { $1 }
 542
 543 types2          :: { [RdrNameHsType]                    {- Two or more -}  }
 544 types2          :  type ',' type                        { [$1,$3] }
 545                 |  type ',' types2                      { $1 : $3 }
 546
 547 btype           :: { RdrNameHsType }
 548 btype           :  atype                                { $1 }
 549                 |  btype atype                          { HsAppTy $1 $2 }
 550
 551 atype           :: { RdrNameHsType }
 552 atype           :  qtc_name                             { HsTyVar $1 }
 553                 |  tv_name                              { HsTyVar $1 }
 554                 |  '.'                                  { hsUsOnce }
 555                 |  '!'                                  { hsUsMany }
 556                 |  '(' ')'                              { HsTupleTy (mkHsTupCon tcName Boxed   []) [] }
 557                 |  '(' types2 ')'                       { HsTupleTy (mkHsTupCon tcName Boxed   $2) $2 }
 558                 |  '(#' types0 '#)'                     { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
 559                 |  '[' type ']'                         { HsListTy  $2 }
 560                 |  '{' qcls_name atypes '}'             { mkHsDictTy $2 $3 }
 561                 |  '{' ipvar_name '::' type '}'         { mkHsIParamTy $2 $4 }
 562                 |  '(' type ')'                         { $2 }
 563
 564 atypes          :: { [RdrNameHsType]    {-  Zero or more -} }
 565 atypes          :                                       { [] }
 566                 |  atype atypes                         { $1 : $2 }
 567 --------------------------------------------------------------------------
 568
 569 -- versions of type/btype/atype that cant begin with '!' (or '.')
 570 -- for use where the kind is definitely known NOT to be '$'
 571
 572 ttype           :: { RdrNameHsType }
 573 ttype           : '__forall' tv_bndrs
 574                         opt_context '=>' type           { mkHsForAllTy (Just $2) $3 $5 }
 575                 | tbtype '->' type                      { HsFunTy $1 $3 }
 576                 | tbtype                                { $1 }
 577
 578 tbtype          :: { RdrNameHsType }
 579 tbtype          :  tatype                               { $1 }
 580                 |  tbtype atype                         { HsAppTy $1 $2 }
 581
 582 tatype          :: { RdrNameHsType }
 583 tatype          :  qtc_name                             { HsTyVar $1 }
 584                 |  tv_name                              { HsTyVar $1 }
 585                 |  '(' ')'                              { HsTupleTy (mkHsTupCon tcName Boxed   []) [] }
 586                 |  '(' types2 ')'                       { HsTupleTy (mkHsTupCon tcName Boxed   $2) $2 }
 587                 |  '(#' types0 '#)'                     { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
 588                 |  '[' type ']'                         { HsListTy  $2 }
 589                 |  '{' qcls_name atypes '}'             { mkHsDictTy $2 $3 }
 590                 |  '{' ipvar_name '::' type '}'         { mkHsIParamTy $2 $4 }
 591                 |  '(' type ')'                         { $2 }
 592 ---------------------------------------------------------------------
 593
 594 package         :: { PackageName }
 595                 :  STRING               { $1 }
 596                 | {- empty -}           { opt_InPackage }
 597                                 -- Useful for .hi-boot files,
 598                                 -- which can omit the package Id
 599                                 -- Module loops are always within a package
 600
 601 mod_name        :: { ModuleName }
 602                 :  CONID                { mkSysModuleNameFS $1 }
 603
 604
 605 ---------------------------------------------------
 606 var_fs          :: { EncodedFS }
 607                 : VARID                 { $1 }
 608                 | 'as'                  { SLIT("as") }
 609                 | 'qualified'           { SLIT("qualified") }
 610                 | 'hiding'              { SLIT("hiding") }
 611                 | 'forall'              { SLIT("forall") }
 612                 | 'foreign'             { SLIT("foreign") }
 613                 | 'export'              { SLIT("export") }
 614                 | 'label'               { SLIT("label") }
 615                 | 'dynamic'             { SLIT("dynamic") }
 616                 | 'unsafe'              { SLIT("unsafe") }
 617                 | 'with'                { SLIT("with") }
 618                 | 'ccall'               { SLIT("ccall") }
 619                 | 'stdcall'             { SLIT("stdcall") }
 620
 621 var_occ         :: { OccName }
 622                 :  var_fs               { mkSysOccFS varName $1 }
 623
 624 var_name        :: { RdrName }
 625 var_name        :  var_occ              { mkRdrUnqual $1 }
 626
 627 qvar_name       :: { RdrName }
 628 qvar_name       :  var_name             { $1 }
 629                 |  QVARID               { mkIfaceOrig varName $1 }
 630
 631 ipvar_name      :: { IPName RdrName }
 632                 : IPDUPVARID            { Dupable (mkRdrUnqual (mkSysOccFS varName $1)) }
 633                 | IPSPLITVARID          { Linear  (mkRdrUnqual (mkSysOccFS varName $1)) }
 634
 635 qvar_names1     :: { [RdrName] }
 636 qvar_names1     : qvar_name             { [$1] }
 637                 | qvar_name qvar_names1 { $1 : $2 }
 638
 639 var_names       :: { [RdrName] }
 640 var_names       :                       { [] }
 641                 | var_name var_names    { $1 : $2 }
 642
 643 var_names1      :: { [RdrName] }
 644 var_names1      : var_name var_names    { $1 : $2 }
 645
 646 ---------------------------------------------------
 647
 648 data_occ        :: { OccName }
 649                 :  CONID                { mkSysOccFS dataName $1 }
 650
 651 qdata_name      :: { RdrName }
 652                 :  data_occ             { mkRdrUnqual $1 }
 653                 |  QCONID               { mkIfaceOrig dataName $1 }
 654
 655 var_or_data_name :: { RdrName }
 656                   : qvar_name           { $1 }
 657                   | qdata_name          { $1 }
 658
 659 ---------------------------------------------------
 660 tc_occ          :: { OccName }
 661                 :  CONID                { mkSysOccFS tcName $1 }
 662
 663 qtc_name        :: { RdrName }
 664                 : tc_occ                { mkRdrUnqual $1 }
 665                 | QCONID                { mkIfaceOrig tcName $1 }
 666
 667 ---------------------------------------------------
 668 qcls_name       :: { RdrName }
 669                 : CONID                 { mkRdrUnqual (mkSysOccFS clsName $1) }
 670                 | QCONID                { mkIfaceOrig clsName $1 }
 671
 672 ---------------------------------------------------
 673 tv_name         :: { RdrName }
 674                 :  var_fs               { mkRdrUnqual (mkSysOccFS tvName $1) }
 675
 676 tv_bndr         :: { HsTyVarBndr RdrName }
 677                 :  tv_name '::' akind   { IfaceTyVar $1 $3 }
 678                 |  tv_name              { IfaceTyVar $1 liftedTypeKind }
 679
 680 tv_bndrs        :: { [HsTyVarBndr RdrName] }
 681                 : tv_bndrs1             { $1 }
 682                 | '[' tv_bndrs1 ']'     { $2 }  -- Backward compatibility
 683
 684 tv_bndrs1       :: { [HsTyVarBndr RdrName] }
 685                 :                       { [] }
 686                 | tv_bndr tv_bndrs1     { $1 : $2 }
 687
 688 ---------------------------------------------------
 689 fds :: { [([RdrName], [RdrName])] }
 690         : {- empty -}                   { [] }
 691         | '|' fds1                      { reverse $2 }
 692
 693 fds1 :: { [([RdrName], [RdrName])] }
 694         : fds1 ',' fd                   { $3 : $1 }
 695         | fd                            { [$1] }
 696
 697 fd :: { ([RdrName], [RdrName]) }
 698         : varids0 '->' varids0          { (reverse $1, reverse $3) }
 699
 700 varids0 :: { [RdrName] }
 701         : {- empty -}                   { [] }
 702         | varids0 tv_name               { $2 : $1 }
 703
 704 ---------------------------------------------------
 705 kind            :: { Kind }
 706                 : akind                 { $1 }
 707                 | akind '->' kind       { mkArrowKind $1 $3 }
 708
 709 akind           :: { Kind }
 710                 : VARSYM                { if $1 == SLIT("*") then
 711                                                 liftedTypeKind
 712                                           else if $1 == SLIT("?") then
 713                                                 openTypeKind
 714                                           else if $1 == SLIT("\36") then
 715                                                 usageTypeKind  -- dollar
 716                                           else panic "ParseInterface: akind"
 717                                         }
 718                 | '(' kind ')'  { $2 }
 719
 720 --------------------------------------------------------------------------
 721
 722 id_info         :: { [HsIdInfo RdrName] }
 723                 : id_info_item                  { [$1] }
 724                 | id_info_item id_info          { $1 : $2 }
 725
 726 id_info_item    :: { HsIdInfo RdrName }
 727                 : '__A' INTEGER                 { HsArity (fromInteger $2) }
 728                 | '__U' activation core_expr    { HsUnfold $2 $3 }
 729                 | '__S'                         { HsStrictness $1 }
 730                 | '__C'                         { HsNoCafRefs }
 731                 | '__P' qvar_name INTEGER       { HsWorker $2 (fromInteger $3) }
 732
 733 -------------------------------------------------------
 734 core_expr       :: { UfExpr RdrName }
 735 core_expr       : '\\' core_bndrs '->' core_expr        { foldr UfLam $4 $2 }
 736                 | 'case' core_expr 'of' var_name
 737                   '{' core_alts '}'                     { UfCase $2 $4 $6 }
 738
 739                 | 'let' '{' core_val_bndr '=' core_expr
 740                       '}' 'in' core_expr                { UfLet (UfNonRec $3 $5) $8 }
 741                 | '__letrec' '{' rec_binds '}'
 742                   'in' core_expr                        { UfLet (UfRec $3) $6 }
 743
 744                 | '__litlit' STRING atype               { UfLitLit $2 $3 }
 745
 746                 | fexpr                                 { $1 }
 747
 748 fexpr   :: { UfExpr RdrName }
 749 fexpr   : fexpr core_arg                                { UfApp $1 $2 }
 750         | scc core_aexpr                                { UfNote (UfSCC $1) $2  }
 751         | '__inline_me' core_aexpr                      { UfNote UfInlineMe $2 }
 752         | '__inline_call' core_aexpr                    { UfNote UfInlineCall $2 }
 753         | '__coerce' atype core_aexpr                   { UfNote (UfCoerce $2) $3 }
 754         | core_aexpr                                    { $1 }
 755
 756 core_arg        :: { UfExpr RdrName }
 757                 : '@' atype                                     { UfType $2 }
 758                 | core_aexpr                                    { $1 }
 759
 760 core_args       :: { [UfExpr RdrName] }
 761                 :                                               { [] }
 762                 | core_arg core_args                            { $1 : $2 }
 763
 764 core_aexpr      :: { UfExpr RdrName }              -- Atomic expressions
 765 core_aexpr      : qvar_name                                     { UfVar $1 }
 766                 | qdata_name                                    { UfVar $1 }
 767
 768                 | core_lit               { UfLit $1 }
 769                 | '(' core_expr ')'      { $2 }
 770
 771                 | '('  ')'               { UfTuple (mkHsTupCon dataName Boxed [])   [] }
 772                 | '(' comma_exprs2 ')'   { UfTuple (mkHsTupCon dataName Boxed $2)   $2 }
 773                 | '(#' comma_exprs0 '#)' { UfTuple (mkHsTupCon dataName Unboxed $2) $2 }
 774
 775                 | '{' '__ccall' ccall_string type '}'
 776                            { let
 777                                  (is_dyn, is_casm, may_gc) = $2
 778
 779                                  target | is_dyn    = DynamicTarget
 780                                         | is_casm   = CasmTarget $3
 781                                         | otherwise = StaticTarget $3
 782
 783                                  ccall = CCallSpec target CCallConv may_gc
 784                              in
 785                              UfFCall (CCall ccall) $4
 786                            }
 787
 788
 789 comma_exprs0    :: { [UfExpr RdrName] } -- Zero or more
 790 comma_exprs0    : {- empty -}                   { [ ] }
 791                 | core_expr                     { [ $1 ] }
 792                 | comma_exprs2                  { $1 }
 793
 794 comma_exprs2    :: { [UfExpr RdrName] } -- Two or more
 795 comma_exprs2    : core_expr ',' core_expr                       { [$1,$3] }
 796                 | core_expr ',' comma_exprs2                    { $1 : $3 }
 797
 798 rec_binds       :: { [(UfBinder RdrName, UfExpr RdrName)] }
 799                 :                                               { [] }
 800                 | core_val_bndr '=' core_expr ';' rec_binds     { ($1,$3) : $5 }
 801
 802 core_alts       :: { [UfAlt RdrName] }
 803                 :                                               { [] }
 804                 | core_alt ';' core_alts                        { $1 : $3 }
 805
 806 core_alt        :: { UfAlt RdrName }
 807 core_alt        : core_pat '->' core_expr       { (fst $1, snd $1, $3) }
 808
 809 core_pat        :: { (UfConAlt RdrName, [RdrName]) }
 810 core_pat        : core_lit                      { (UfLitAlt  $1, []) }
 811                 | '__litlit' STRING atype       { (UfLitLitAlt $2 $3, []) }
 812                 | qdata_name core_pat_names     { (UfDataAlt $1, $2) }
 813                 | '('  ')'                      { (UfTupleAlt (mkHsTupCon dataName Boxed []),   []) }
 814                 | '(' comma_var_names1 ')'      { (UfTupleAlt (mkHsTupCon dataName Boxed $2),   $2) }
 815                 | '(#' comma_var_names1 '#)'    { (UfTupleAlt (mkHsTupCon dataName Unboxed $2), $2) }
 816                 | '__DEFAULT'                   { (UfDefault, []) }
 817                 | '(' core_pat ')'              { $2 }
 818
 819 core_pat_names :: { [RdrName] }
 820 core_pat_names :                                { [] }
 821                 | core_pat_name core_pat_names  { $1 : $2 }
 822
 823 -- Tyvar names and variable names live in different name spaces
 824 -- so they need to be signalled separately.  But we don't record
 825 -- types or kinds in a pattern; we work that out from the type
 826 -- of the case scrutinee
 827 core_pat_name   :: { RdrName }
 828 core_pat_name   : var_name                      { $1 }
 829                 | '@' tv_name                   { $2 }
 830
 831 comma_var_names1 :: { [RdrName] }       -- One or more
 832 comma_var_names1 : var_name                                     { [$1] }
 833                  | var_name ',' comma_var_names1                { $1 : $3 }
 834
 835 core_lit        :: { Literal }
 836 core_lit        : integer                       { mkMachInt $1 }
 837                 | CHAR                          { MachChar $1 }
 838                 | STRING                        { MachStr $1 }
 839                 | rational                      { MachDouble $1 }
 840                 | '__word' integer              { mkMachWord $2 }
 841                 | '__word64' integer            { mkMachWord64 $2 }
 842                 | '__int64' integer             { mkMachInt64 $2 }
 843                 | '__float' rational            { MachFloat $2 }
 844                 | '__addr' integer              { MachAddr $2 }
 845                 | '__label' STRING              { MachLabel $2 }
 846
 847 integer         :: { Integer }
 848                 : INTEGER                       { $1 }
 849                 | '-' INTEGER                   { (-$2) }
 850
 851 rational        :: { Rational }
 852                 : RATIONAL                      { $1 }
 853                 | '-' RATIONAL                  { (-$2) }
 854
 855 core_bndr       :: { UfBinder RdrName }
 856 core_bndr       : core_val_bndr                                 { $1 }
 857                 | core_tv_bndr                                  { $1 }
 858
 859 core_bndrs      :: { [UfBinder RdrName] }
 860 core_bndrs      :                                               { [] }
 861                 | core_bndr core_bndrs                          { $1 : $2 }
 862
 863 core_val_bndr   :: { UfBinder RdrName }
 864 core_val_bndr   : var_name '::' atype                           { UfValBinder $1 $3 }
 865
 866 core_tv_bndr    :: { UfBinder RdrName }
 867 core_tv_bndr    :  '@' tv_name '::' akind               { UfTyBinder $2 $4 }
 868                 |  '@' tv_name                          { UfTyBinder $2 liftedTypeKind }
 869
 870 ccall_string    :: { FAST_STRING }
 871                 : STRING                                        { $1 }
 872                 | CLITLIT                                       { $1 }
 873                 | VARID                                         { $1 }
 874                 | CONID                                         { $1 }
 875
 876 ------------------------------------------------------------------------
 877 scc     :: { CostCentre }
 878         :  '__sccC' '{' mod_name '}'                      { AllCafsCC $3 }
 879         |  '__scc' '{' cc_name mod_name cc_dup cc_caf '}'
 880                              { NormalCC { cc_name = $3, cc_mod = $4,
 881                                           cc_is_dupd = $5, cc_is_caf = $6 } }
 882
 883 cc_name :: { EncodedFS }
 884         : CONID                 { $1 }
 885         | var_fs                { $1 }
 886
 887 cc_dup  :: { IsDupdCC }
 888 cc_dup  :                       { OriginalCC }
 889         | '!'                   { DupdCC }
 890
 891 cc_caf  :: { IsCafCC }
 892         :                       { NotCafCC }
 893         | '__C'                 { CafCC }
 894
 895 -------------------------------------------------------------------
 896
 897 src_loc :: { SrcLoc }
 898 src_loc :                               {% getSrcLocP }
 899
 900 -- Check the project version: this makes sure
 901 -- that the project version (e.g. 407) in the interface
 902 -- file is the same as that for the compiler that's reading it
 903 checkVersion :: { () }
 904            : {-empty-}                  {% checkVersion Nothing }
 905            | INTEGER                    {% checkVersion (Just (fromInteger $1)) }
 906
 907 -------------------------------------------------------------------
 908
 909 --                      Haskell code
 910 {
 911 happyError :: P a
 912 happyError buf PState{ loc = loc } = PFailed (ifaceParseErr buf loc)
 913
 914 mk_con_decl name (ex_tvs, ex_ctxt) details loc = mkConDecl name ex_tvs ex_ctxt details loc
 915 }