{- -*-haskell-*-
-----------------------------------------------------------------------------
-$Id: Parser.y,v 1.106 2002/10/09 15:03:53 simonpj Exp $
+$Id: Parser.y,v 1.129 2003/11/06 17:09:53 simonpj Exp $
Haskell grammar.
#include "HsVersions.h"
import HsSyn
-import HsTypes ( mkHsTupCon )
-
import RdrHsSyn
-import HscTypes ( ParsedIface(..), IsBootInterface )
-import Lex
+import HscTypes ( ModIface, IsBootInterface, DeprecTxt )
+import Lexer
import RdrName
-import PrelNames ( mAIN_Name, funTyConName, listTyConName,
- parrTyConName, consDataConName, nilDataConName )
-import TysWiredIn ( unitTyCon, unitDataCon, tupleTyCon, tupleCon )
+import TysWiredIn ( unitTyCon, unitDataCon, tupleTyCon, tupleCon, nilDataCon,
+ listTyCon_RDR, parrTyCon_RDR, consDataCon_RDR )
+import Type ( funTyCon )
import ForeignCall ( Safety(..), CExportSpec(..),
- CCallConv(..), CCallTarget(..), defaultCCallConv,
+ CCallConv(..), CCallTarget(..), defaultCCallConv
)
-import OccName ( UserFS, varName, tcName, dataName, tcClsName, tvName )
-import TyCon ( DataConDetails(..) )
-import SrcLoc ( SrcLoc )
+import OccName ( UserFS, varName, dataName, tcClsName, tvName )
+import DataCon ( DataCon, dataConName )
+import SrcLoc ( SrcLoc, noSrcLoc )
import Module
-import CmdLineOpts ( opt_SccProfilingOn, opt_InPackage )
+import CmdLineOpts ( opt_SccProfilingOn )
import Type ( Kind, mkArrowKind, liftedTypeKind )
import BasicTypes ( Boxity(..), Fixity(..), FixityDirection(..), IPName(..),
- NewOrData(..), StrictnessMark(..), Activation(..),
- FixitySig(..) )
+ NewOrData(..), Activation(..) )
import Panic
import GLAEXTS
import FastString
import Maybes ( orElse )
import Outputable
+import Char ( ord )
}
-}
%token
- '_' { ITunderscore } -- Haskell keywords
- 'as' { ITas }
- 'case' { ITcase }
- 'class' { ITclass }
- 'data' { ITdata }
- 'default' { ITdefault }
- 'deriving' { ITderiving }
- 'do' { ITdo }
- 'else' { ITelse }
- 'hiding' { IThiding }
- 'if' { ITif }
- 'import' { ITimport }
- 'in' { ITin }
- 'infix' { ITinfix }
- 'infixl' { ITinfixl }
- 'infixr' { ITinfixr }
- 'instance' { ITinstance }
- 'let' { ITlet }
- 'module' { ITmodule }
- 'newtype' { ITnewtype }
- 'of' { ITof }
- 'qualified' { ITqualified }
- 'then' { ITthen }
- 'type' { ITtype }
- 'where' { ITwhere }
- '_scc_' { ITscc } -- ToDo: remove
-
- 'forall' { ITforall } -- GHC extension keywords
- 'foreign' { ITforeign }
- 'export' { ITexport }
- 'label' { ITlabel }
- 'dynamic' { ITdynamic }
- 'safe' { ITsafe }
- 'threadsafe' { ITthreadsafe }
- 'unsafe' { ITunsafe }
- 'with' { ITwith }
- 'mdo' { ITmdo }
- 'stdcall' { ITstdcallconv }
- 'ccall' { ITccallconv }
- 'dotnet' { ITdotnet }
- '_ccall_' { ITccall (False, False, PlayRisky) }
- '_ccall_GC_' { ITccall (False, False, PlaySafe False) }
- '_casm_' { ITccall (False, True, PlayRisky) }
- '_casm_GC_' { ITccall (False, True, PlaySafe False) }
-
- '{-# SPECIALISE' { ITspecialise_prag }
- '{-# SOURCE' { ITsource_prag }
- '{-# INLINE' { ITinline_prag }
- '{-# NOINLINE' { ITnoinline_prag }
- '{-# RULES' { ITrules_prag }
- '{-# SCC' { ITscc_prag }
- '{-# DEPRECATED' { ITdeprecated_prag }
- '#-}' { ITclose_prag }
-
-{-
- '__interface' { ITinterface } -- interface keywords
- '__export' { IT__export }
- '__instimport' { ITinstimport }
- '__forall' { IT__forall }
- '__letrec' { ITletrec }
- '__coerce' { ITcoerce }
- '__depends' { ITdepends }
- '__inline' { ITinline }
- '__DEFAULT' { ITdefaultbranch }
- '__bot' { ITbottom }
- '__integer' { ITinteger_lit }
- '__float' { ITfloat_lit }
- '__rational' { ITrational_lit }
- '__addr' { ITaddr_lit }
- '__label' { ITlabel_lit }
- '__litlit' { ITlit_lit }
- '__string' { ITstring_lit }
- '__ccall' { ITccall $$ }
- '__scc' { IT__scc }
- '__sccC' { ITsccAllCafs }
-
- '__A' { ITarity }
- '__P' { ITspecialise }
- '__C' { ITnocaf }
- '__U' { ITunfold }
- '__S' { ITstrict $$ }
- '__M' { ITcprinfo $$ }
--}
-
- '..' { ITdotdot } -- reserved symbols
- ':' { ITcolon }
- '::' { ITdcolon }
- '=' { ITequal }
- '\\' { ITlam }
- '|' { ITvbar }
- '<-' { ITlarrow }
- '->' { ITrarrow }
- '@' { ITat }
- '~' { ITtilde }
- '=>' { ITdarrow }
- '-' { ITminus }
- '!' { ITbang }
- '*' { ITstar }
- '.' { ITdot }
-
- '{' { ITocurly } -- special symbols
- '}' { ITccurly }
- '{|' { ITocurlybar }
- '|}' { ITccurlybar }
- vccurly { ITvccurly } -- virtual close curly (from layout)
- '[' { ITobrack }
- ']' { ITcbrack }
- '[:' { ITopabrack }
- ':]' { ITcpabrack }
- '(' { IToparen }
- ')' { ITcparen }
- '(#' { IToubxparen }
- '#)' { ITcubxparen }
- ';' { ITsemi }
- ',' { ITcomma }
- '`' { ITbackquote }
-
- VARID { ITvarid $$ } -- identifiers
- CONID { ITconid $$ }
- VARSYM { ITvarsym $$ }
- CONSYM { ITconsym $$ }
- QVARID { ITqvarid $$ }
- QCONID { ITqconid $$ }
- QVARSYM { ITqvarsym $$ }
- QCONSYM { ITqconsym $$ }
-
- IPDUPVARID { ITdupipvarid $$ } -- GHC extension
- IPSPLITVARID { ITsplitipvarid $$ } -- GHC extension
-
- CHAR { ITchar $$ }
- STRING { ITstring $$ }
- INTEGER { ITinteger $$ }
- RATIONAL { ITrational $$ }
-
- PRIMCHAR { ITprimchar $$ }
- PRIMSTRING { ITprimstring $$ }
- PRIMINTEGER { ITprimint $$ }
- PRIMFLOAT { ITprimfloat $$ }
- PRIMDOUBLE { ITprimdouble $$ }
- CLITLIT { ITlitlit $$ }
+ '_' { T _ _ ITunderscore } -- Haskell keywords
+ 'as' { T _ _ ITas }
+ 'case' { T _ _ ITcase }
+ 'class' { T _ _ ITclass }
+ 'data' { T _ _ ITdata }
+ 'default' { T _ _ ITdefault }
+ 'deriving' { T _ _ ITderiving }
+ 'do' { T _ _ ITdo }
+ 'else' { T _ _ ITelse }
+ 'hiding' { T _ _ IThiding }
+ 'if' { T _ _ ITif }
+ 'import' { T _ _ ITimport }
+ 'in' { T _ _ ITin }
+ 'infix' { T _ _ ITinfix }
+ 'infixl' { T _ _ ITinfixl }
+ 'infixr' { T _ _ ITinfixr }
+ 'instance' { T _ _ ITinstance }
+ 'let' { T _ _ ITlet }
+ 'module' { T _ _ ITmodule }
+ 'newtype' { T _ _ ITnewtype }
+ 'of' { T _ _ ITof }
+ 'qualified' { T _ _ ITqualified }
+ 'then' { T _ _ ITthen }
+ 'type' { T _ _ ITtype }
+ 'where' { T _ _ ITwhere }
+ '_scc_' { T _ _ ITscc } -- ToDo: remove
+
+ 'forall' { T _ _ ITforall } -- GHC extension keywords
+ 'foreign' { T _ _ ITforeign }
+ 'export' { T _ _ ITexport }
+ 'label' { T _ _ ITlabel }
+ 'dynamic' { T _ _ ITdynamic }
+ 'safe' { T _ _ ITsafe }
+ 'threadsafe' { T _ _ ITthreadsafe }
+ 'unsafe' { T _ _ ITunsafe }
+ 'mdo' { T _ _ ITmdo }
+ 'stdcall' { T _ _ ITstdcallconv }
+ 'ccall' { T _ _ ITccallconv }
+ 'dotnet' { T _ _ ITdotnet }
+ 'proc' { T _ _ ITproc } -- for arrow notation extension
+ 'rec' { T _ _ ITrec } -- for arrow notation extension
+
+ '{-# SPECIALISE' { T _ _ ITspecialise_prag }
+ '{-# SOURCE' { T _ _ ITsource_prag }
+ '{-# INLINE' { T _ _ ITinline_prag }
+ '{-# NOINLINE' { T _ _ ITnoinline_prag }
+ '{-# RULES' { T _ _ ITrules_prag }
+ '{-# CORE' { T _ _ ITcore_prag } -- hdaume: annotated core
+ '{-# SCC' { T _ _ ITscc_prag }
+ '{-# DEPRECATED' { T _ _ ITdeprecated_prag }
+ '#-}' { T _ _ ITclose_prag }
+
+ '..' { T _ _ ITdotdot } -- reserved symbols
+ ':' { T _ _ ITcolon }
+ '::' { T _ _ ITdcolon }
+ '=' { T _ _ ITequal }
+ '\\' { T _ _ ITlam }
+ '|' { T _ _ ITvbar }
+ '<-' { T _ _ ITlarrow }
+ '->' { T _ _ ITrarrow }
+ '@' { T _ _ ITat }
+ '~' { T _ _ ITtilde }
+ '=>' { T _ _ ITdarrow }
+ '-' { T _ _ ITminus }
+ '!' { T _ _ ITbang }
+ '*' { T _ _ ITstar }
+ '-<' { T _ _ ITlarrowtail } -- for arrow notation
+ '>-' { T _ _ ITrarrowtail } -- for arrow notation
+ '-<<' { T _ _ ITLarrowtail } -- for arrow notation
+ '>>-' { T _ _ ITRarrowtail } -- for arrow notation
+ '.' { T _ _ ITdot }
+
+ '{' { T _ _ ITocurly } -- special symbols
+ '}' { T _ _ ITccurly }
+ '{|' { T _ _ ITocurlybar }
+ '|}' { T _ _ ITccurlybar }
+ vocurly { T _ _ ITvocurly } -- virtual open curly (from layout)
+ vccurly { T _ _ ITvccurly } -- virtual close curly (from layout)
+ '[' { T _ _ ITobrack }
+ ']' { T _ _ ITcbrack }
+ '[:' { T _ _ ITopabrack }
+ ':]' { T _ _ ITcpabrack }
+ '(' { T _ _ IToparen }
+ ')' { T _ _ ITcparen }
+ '(#' { T _ _ IToubxparen }
+ '#)' { T _ _ ITcubxparen }
+ '(|' { T _ _ IToparenbar }
+ '|)' { T _ _ ITcparenbar }
+ ';' { T _ _ ITsemi }
+ ',' { T _ _ ITcomma }
+ '`' { T _ _ ITbackquote }
+
+ VARID { T _ _ (ITvarid $$) } -- identifiers
+ CONID { T _ _ (ITconid $$) }
+ VARSYM { T _ _ (ITvarsym $$) }
+ CONSYM { T _ _ (ITconsym $$) }
+ QVARID { T _ _ (ITqvarid $$) }
+ QCONID { T _ _ (ITqconid $$) }
+ QVARSYM { T _ _ (ITqvarsym $$) }
+ QCONSYM { T _ _ (ITqconsym $$) }
+
+ IPDUPVARID { T _ _ (ITdupipvarid $$) } -- GHC extension
+ IPSPLITVARID { T _ _ (ITsplitipvarid $$) } -- GHC extension
+
+ CHAR { T _ _ (ITchar $$) }
+ STRING { T _ _ (ITstring $$) }
+ INTEGER { T _ _ (ITinteger $$) }
+ RATIONAL { T _ _ (ITrational $$) }
+
+ PRIMCHAR { T _ _ (ITprimchar $$) }
+ PRIMSTRING { T _ _ (ITprimstring $$) }
+ PRIMINTEGER { T _ _ (ITprimint $$) }
+ PRIMFLOAT { T _ _ (ITprimfloat $$) }
+ PRIMDOUBLE { T _ _ (ITprimdouble $$) }
-- Template Haskell
-'[|' { ITopenExpQuote }
-'[p|' { ITopenPatQuote }
-'[t|' { ITopenTypQuote }
-'[d|' { ITopenDecQuote }
-'|]' { ITcloseQuote }
-ID_SPLICE { ITidEscape $$ } -- $x
-'$(' { ITparenEscape } -- $( exp )
-
-%monad { P } { thenP } { returnP }
-%lexer { lexer } { ITeof }
+'[|' { T _ _ ITopenExpQuote }
+'[p|' { T _ _ ITopenPatQuote }
+'[t|' { T _ _ ITopenTypQuote }
+'[d|' { T _ _ ITopenDecQuote }
+'|]' { T _ _ ITcloseQuote }
+TH_ID_SPLICE { T _ _ (ITidEscape $$) } -- $x
+'$(' { T _ _ ITparenEscape } -- $( exp )
+TH_VAR_QUOTE { T _ _ ITvarQuote } -- 'x
+TH_TY_QUOTE { T _ _ ITtyQuote } -- ''T
+
+%monad { P } { >>= } { return }
+%lexer { lexer } { T _ _ ITeof }
%name parseModule module
%name parseStmt maybe_stmt
%name parseIdentifier identifier
module :: { RdrNameHsModule }
: srcloc 'module' modid maybemoddeprec maybeexports 'where' body
- { HsModule (mkHomeModule $3) Nothing $5 (fst $7) (snd $7) $4 $1 }
- | srcloc body
- { HsModule (mkHomeModule mAIN_Name) Nothing Nothing
- (fst $2) (snd $2) Nothing $1 }
+ { HsModule (Just (mkHomeModule $3)) $5 (fst $7) (snd $7) $4 $1 }
+ | srcloc missing_module_keyword top close
+ { HsModule Nothing Nothing (fst $3) (snd $3) Nothing $1 }
+
+missing_module_keyword :: { () }
+ : {- empty -} {% pushCurrentContext }
maybemoddeprec :: { Maybe DeprecTxt }
: '{-# DEPRECATED' STRING '#-}' { Just $2 }
body :: { ([RdrNameImportDecl], [RdrNameHsDecl]) }
: '{' top '}' { $2 }
- | layout_on top close { $2 }
+ | vocurly top close { $2 }
top :: { ([RdrNameImportDecl], [RdrNameHsDecl]) }
: importdecls { (reverse $1,[]) }
-----------------------------------------------------------------------------
-- Interfaces (.hi-boot files)
-iface :: { ParsedIface }
- : 'module' modid 'where' ifacebody
- { ParsedIface {
- pi_mod = $2,
- pi_pkg = opt_InPackage,
- pi_vers = 1, -- Module version
- pi_orphan = False,
- pi_exports = (1,[($2,mkIfaceExports $4)]),
- pi_usages = [],
- pi_fixity = [],
- pi_insts = [],
- pi_decls = map (\x -> (1,x)) $4,
- pi_rules = (1,[]),
- pi_deprecs = Nothing
- }
- }
-
-ifacebody :: { [RdrNameTyClDecl] }
+iface :: { ModIface }
+ : 'module' modid 'where' ifacebody { mkBootIface $2 $4 }
+
+ifacebody :: { [HsDecl RdrName] }
: '{' ifacedecls '}' { $2 }
- | layout_on ifacedecls close { $2 }
+ | vocurly ifacedecls close { $2 }
-ifacedecls :: { [RdrNameTyClDecl] }
+ifacedecls :: { [HsDecl RdrName] }
: ifacedecl ';' ifacedecls { $1 : $3 }
| ';' ifacedecls { $2 }
| ifacedecl { [$1] }
| {- empty -} { [] }
-ifacedecl :: { RdrNameTyClDecl }
- : tycl_decl { $1 }
- | srcloc var '::' sigtype { IfaceSig $2 $4 [] $1 }
+ifacedecl :: { HsDecl RdrName }
+ : var '::' sigtype
+ { SigD (Sig $1 $3 noSrcLoc) }
+ | 'type' syn_hdr '=' ctype
+ { let (tc,tvs) = $2 in TyClD (TySynonym tc tvs $4 noSrcLoc) }
+ | new_or_data tycl_hdr
+ { TyClD (mkTyData $1 $2 [] Nothing noSrcLoc) }
+ | 'class' tycl_hdr fds
+ { TyClD (mkClassDecl $2 $3 [] EmptyMonoBinds noSrcLoc) }
+
+new_or_data :: { NewOrData }
+ : 'data' { DataType }
+ | 'newtype' { NewType }
-----------------------------------------------------------------------------
-- The Export List
: tycl_decl { RdrHsDecl (TyClD $1) }
| srcloc 'instance' inst_type where
{ let (binds,sigs) = cvMonoBindsAndSigs $4
- in RdrHsDecl (InstD (InstDecl $3 binds sigs Nothing $1)) }
+ in RdrHsDecl (InstD (InstDecl $3 binds sigs $1)) }
| srcloc 'default' '(' comma_types0 ')' { RdrHsDecl (DefD (DefaultDecl $4 $1)) }
| 'foreign' fdecl { RdrHsDecl $2 }
- | '{-# DEPRECATED' deprecations '#-}' { RdrBindings $2 }
- | '{-# RULES' rules '#-}' { RdrBindings $2 }
- | '$(' exp ')' { RdrHsDecl (SpliceD $2) }
+ | '{-# DEPRECATED' deprecations '#-}' { RdrBindings (reverse $2) }
+ | '{-# RULES' rules '#-}' { RdrBindings (reverse $2) }
+ | srcloc '$(' exp ')' { RdrHsDecl (SpliceD (SpliceDecl $3 $1)) }
| decl { $1 }
tycl_decl :: { RdrNameTyClDecl }
-- Instead we just say b is out of scope
{ let (tc,tvs) = $3 in TySynonym tc tvs $5 $1 }
-
| srcloc 'data' tycl_hdr constrs deriving
- { mkTyData DataType $3 (DataCons (reverse $4)) $5 $1 }
+ { mkTyData DataType $3 (reverse $4) $5 $1 }
| srcloc 'newtype' tycl_hdr '=' newconstr deriving
- { mkTyData NewType $3 (DataCons [$5]) $6 $1 }
+ { mkTyData NewType $3 [$5] $6 $1 }
| srcloc 'class' tycl_hdr fds where
{ let
(binds,sigs) = cvMonoBindsAndSigs $5
in
- mkClassDecl $3 $4 (map cvClassOpSig sigs) (Just binds) $1 }
+ mkClassDecl $3 $4 sigs binds $1 }
syn_hdr :: { (RdrName, [RdrNameHsTyVar]) } -- We don't retain the syntax of an infix
-- type synonym declaration. Oh well.
-- (Eq a, Ord b) => T a b
-- Rather a lot of inlining here, else we get reduce/reduce errors
tycl_hdr :: { (RdrNameContext, RdrName, [RdrNameHsTyVar]) }
- : context '=>' type {% checkTyClHdr $3 `thenP` \ (tc,tvs) ->
- returnP ($1, tc, tvs) }
- | type {% checkTyClHdr $1 `thenP` \ (tc,tvs) ->
- returnP ([], tc, tvs) }
+ : context '=>' type {% checkTyClHdr $1 $3 }
+ | type {% checkTyClHdr [] $1 }
-----------------------------------------------------------------------------
-- Nested declarations
| {- empty -} { [] }
-wherebinds :: { RdrNameHsBinds }
- : where { cvBinds $1 }
+decllist :: { [RdrBinding] } -- Reversed
+ : '{' decls '}' { $2 }
+ | vocurly decls close { $2 }
where :: { [RdrBinding] } -- Reversed
+ -- No implicit parameters
: 'where' decllist { $2 }
| {- empty -} { [] }
-decllist :: { [RdrBinding] } -- Reversed
- : '{' decls '}' { $2 }
- | layout_on decls close { $2 }
+binds :: { RdrNameHsBinds } -- May have implicit parameters
+ : decllist { cvBinds $1 }
+ | '{' dbinds '}' { IPBinds $2 }
+ | vocurly dbinds close { IPBinds $2 }
-letbinds :: { RdrNameHsExpr -> RdrNameHsExpr }
- : decllist { HsLet (cvBinds $1) }
- | '{' dbinds '}' { \e -> HsWith e $2 False{-not with-} }
- | layout_on dbinds close { \e -> HsWith e $2 False{-not with-} }
+wherebinds :: { RdrNameHsBinds } -- May have implicit parameters
+ : 'where' binds { $2 }
+ | {- empty -} { EmptyBinds }
-----------------------------------------------------------------------------
-- Transformation Rules
-rules :: { [RdrBinding] }
- : rule ';' rules { $1 : $3 }
+rules :: { [RdrBinding] } -- Reversed
+ : rules ';' rule { $3 : $1 }
+ | rules ';' { $1 }
| rule { [$1] }
| {- empty -} { [] }
| '(' varid '::' ctype ')' { RuleBndrSig $2 $4 }
-----------------------------------------------------------------------------
--- Deprecations
+-- Deprecations (c.f. rules)
-deprecations :: { [RdrBinding] }
- : deprecation ';' deprecations { $1 : $3 }
+deprecations :: { [RdrBinding] } -- Reversed
+ : deprecations ';' deprecation { $3 : $1 }
+ | deprecations ';' { $1 }
| deprecation { [$1] }
| {- empty -} { [] }
| 'import' callconv STRING STRING safety varid_no_unsafe '::' sigtype
{% case $2 of
DNCall -> parseError "Illegal format of .NET foreign import"
- CCall cconv -> returnP $
+ CCall cconv -> return $
let
imp = CFunction (StaticTarget $4)
in
| 'import' callconv STRING 'unsafe' varid_no_unsafe '::' sigtype
{% case $2 of
DNCall -> parseError "Illegal format of .NET foreign import"
- CCall cconv -> returnP $
+ CCall cconv -> return $
let
imp = CFunction (StaticTarget $3)
in
| 'import' callconv 'dynamic' safety varid_no_unsafe '::' sigtype
{% case $2 of
DNCall -> parseError "Illegal format of .NET foreign import"
- CCall cconv -> returnP $
+ CCall cconv -> return $
ForeignImport $5 $7 (CImport cconv $4 nilFS nilFS
(CFunction DynamicTarget)) }
| 'export' callconv STRING STRING varid '::' sigtype
{% case $2 of
DNCall -> parseError "Illegal format of .NET foreign import"
- CCall cconv -> returnP $
+ CCall cconv -> return $
ForeignExport $5 $7
(CExport (CExportStatic $4 cconv)) }
| 'export' callconv 'dynamic' varid '::' sigtype
{% case $2 of
DNCall -> parseError "Illegal format of .NET foreign import"
- CCall cconv -> returnP $
+ CCall cconv -> return $
ForeignImport $4 $6 (CImport cconv (PlaySafe False) nilFS nilFS CWrapper) }
----------- DEPRECATED .NET decls ------------
| sigtypes ',' sigtype { $3 : $1 }
sigtype :: { RdrNameHsType }
- : ctype { mkHsForAllTy Nothing [] $1 }
+ : ctype { mkImplicitHsForAllTy [] $1 }
+ -- Wrap an Implicit forall if there isn't one there already
sig_vars :: { [RdrName] }
: sig_vars ',' var { $3 : $1 }
-- A ctype is a for-all type
ctype :: { RdrNameHsType }
- : 'forall' tv_bndrs '.' ctype { mkHsForAllTy (Just $2) [] $4 }
- | context '=>' type { mkHsForAllTy Nothing $1 $3 }
+ : 'forall' tv_bndrs '.' ctype { mkExplicitHsForAllTy $2 [] $4 }
+ | context '=>' type { mkImplicitHsForAllTy $1 $3 }
-- A type of form (context => type) is an *implicit* HsForAllTy
| type { $1 }
gentype :: { RdrNameHsType }
: btype { $1 }
- | btype qtyconop gentype { HsOpTy $1 (HsTyOp $2) $3 }
- | btype '`' tyvar '`' gentype { HsOpTy $1 (HsTyOp $3) $5 }
- | btype '->' gentype { HsOpTy $1 HsArrow $3 }
+ | btype qtyconop gentype { HsOpTy $1 $2 $3 }
+ | btype '`' tyvar '`' gentype { HsOpTy $1 $3 $5 }
+ | btype '->' gentype { HsFunTy $1 $3 }
btype :: { RdrNameHsType }
: btype atype { HsAppTy $1 $2 }
atype :: { RdrNameHsType }
: gtycon { HsTyVar $1 }
| tyvar { HsTyVar $1 }
- | '(' type ',' comma_types1 ')' { HsTupleTy (mkHsTupCon tcName Boxed ($2:$4)) ($2:$4) }
- | '(#' comma_types1 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
+ | '(' type ',' comma_types1 ')' { HsTupleTy Boxed ($2:$4) }
+ | '(#' comma_types1 '#)' { HsTupleTy Unboxed $2 }
| '[' type ']' { HsListTy $2 }
| '[:' type ':]' { HsPArrTy $2 }
| '(' ctype ')' { HsParTy $2 }
tv_bndr :: { RdrNameHsTyVar }
: tyvar { UserTyVar $1 }
- | '(' tyvar '::' kind ')' { IfaceTyVar $2 $4 }
+ | '(' tyvar '::' kind ')' { KindedTyVar $2 $4 }
fds :: { [([RdrName], [RdrName])] }
: {- empty -} { [] }
constr_stuff :: { (RdrName, RdrNameConDetails) }
: btype {% mkPrefixCon $1 [] }
- | btype '!' atype satypes {% mkPrefixCon $1 (BangType MarkedUserStrict $3 : $4) }
+ | btype strict_mark atype satypes {% mkPrefixCon $1 (BangType $2 $3 : $4) }
| oqtycon '{' '}' {% mkRecCon $1 [] }
| oqtycon '{' fielddecls '}' {% mkRecCon $1 $3 }
| sbtype conop sbtype { ($2, InfixCon $1 $3) }
satypes :: { [RdrNameBangType] }
: atype satypes { unbangedType $1 : $2 }
- | '!' atype satypes { BangType MarkedUserStrict $2 : $3 }
+ | strict_mark atype satypes { BangType $1 $2 : $3 }
| {- empty -} { [] }
sbtype :: { RdrNameBangType }
: btype { unbangedType $1 }
- | '!' atype { BangType MarkedUserStrict $2 }
+ | strict_mark atype { BangType $1 $2 }
fielddecls :: { [([RdrName],RdrNameBangType)] }
: fielddecl ',' fielddecls { $1 : $3 }
stype :: { RdrNameBangType }
: ctype { unbangedType $1 }
- | '!' atype { BangType MarkedUserStrict $2 }
+ | strict_mark atype { BangType $1 $2 }
+
+strict_mark :: { HsBang }
+ : '!' { HsStrict }
+ | '!' '!' { HsUnbox }
deriving :: { Maybe RdrNameContext }
: {- empty -} { Nothing }
exp :: { RdrNameHsExpr }
: infixexp '::' sigtype { ExprWithTySig $1 $3 }
- | infixexp 'with' dbinding { HsWith $1 $3 True{-not a let-} }
+ | fexp srcloc '-<' exp { HsArrApp $1 $4 placeHolderType HsFirstOrderApp True $2 }
+ | fexp srcloc '>-' exp { HsArrApp $4 $1 placeHolderType HsFirstOrderApp False $2 }
+ | fexp srcloc '-<<' exp { HsArrApp $1 $4 placeHolderType HsHigherOrderApp True $2 }
+ | fexp srcloc '>>-' exp { HsArrApp $4 $1 placeHolderType HsHigherOrderApp False $2 }
| infixexp { $1 }
infixexp :: { RdrNameHsExpr }
exp10 :: { RdrNameHsExpr }
: '\\' srcloc aexp aexps opt_asig '->' srcloc exp
- {% checkPatterns $2 ($3 : reverse $4) `thenP` \ ps ->
- returnP (HsLam (Match ps $5
+ {% checkPatterns $2 ($3 : reverse $4) >>= \ ps ->
+ return (HsLam (Match ps $5
(GRHSs (unguardedRHS $8 $7)
EmptyBinds placeHolderType))) }
- | 'let' letbinds 'in' exp { $2 $4 }
+ | 'let' binds 'in' exp { HsLet $2 $4 }
| 'if' srcloc exp 'then' exp 'else' exp { HsIf $3 $5 $7 $2 }
| 'case' srcloc exp 'of' altslist { HsCase $3 $5 $2 }
| '-' fexp { mkHsNegApp $2 }
- | srcloc 'do' stmtlist {% checkDo $3 `thenP` \ stmts ->
- returnP (mkHsDo DoExpr stmts $1) }
- | srcloc 'mdo' stmtlist {% checkMDo $3 `thenP` \ stmts ->
- returnP (mkHsDo MDoExpr stmts $1) }
-
- | '_ccall_' ccallid aexps0 { HsCCall $2 $3 PlayRisky False placeHolderType }
- | '_ccall_GC_' ccallid aexps0 { HsCCall $2 $3 (PlaySafe False) False placeHolderType }
- | '_casm_' CLITLIT aexps0 { HsCCall $2 $3 PlayRisky True placeHolderType }
- | '_casm_GC_' CLITLIT aexps0 { HsCCall $2 $3 (PlaySafe False) True placeHolderType }
+ | srcloc 'do' stmtlist {% checkDo $3 >>= \ stmts ->
+ return (mkHsDo DoExpr stmts $1) }
+ | srcloc 'mdo' stmtlist {% checkMDo $3 >>= \ stmts ->
+ return (mkHsDo MDoExpr stmts $1) }
| scc_annot exp { if opt_SccProfilingOn
then HsSCC $1 $2
else HsPar $2 }
+ | 'proc' srcloc aexp '->' srcloc exp
+ {% checkPattern $2 $3 >>= \ p ->
+ return (HsProc p (HsCmdTop $6 [] placeHolderType undefined) $5) }
+
+ | '{-# CORE' STRING '#-}' exp { HsCoreAnn $2 $4 } -- hdaume: core annotation
+
| fexp { $1 }
scc_annot :: { FastString }
: '_scc_' STRING { $2 }
| '{-# SCC' STRING '#-}' { $2 }
-ccallid :: { FastString }
- : VARID { $1 }
- | CONID { $1 }
-
fexp :: { RdrNameHsExpr }
- : fexp aexp { (HsApp $1 $2) }
+ : fexp aexp { HsApp $1 $2 }
| aexp { $1 }
-aexps0 :: { [RdrNameHsExpr] }
- : aexps { reverse $1 }
-
aexps :: { [RdrNameHsExpr] }
: aexps aexp { $2 : $1 }
| {- empty -} { [] }
-- Here was the syntax for type applications that I was planning
-- but there are difficulties (e.g. what order for type args)
-- so it's not enabled yet.
- | qcname '{|' gentype '|}' { (HsApp (HsVar $1) (HsType $3)) }
+-- But this case *is* used for the left hand side of a generic definition,
+-- which is parsed as an expression before being munged into a pattern
+ | qcname '{|' gentype '|}' { (HsApp (HsVar $1) (HsType $3)) }
aexp2 :: { RdrNameHsExpr }
: ipvar { HsIPVar $1 }
| qcname { HsVar $1 }
| literal { HsLit $1 }
- | INTEGER { HsOverLit (mkHsIntegral $1) }
- | RATIONAL { HsOverLit (mkHsFractional $1) }
+ | INTEGER { HsOverLit $! mkHsIntegral $1 }
+ | RATIONAL { HsOverLit $! mkHsFractional $1 }
| '(' exp ')' { HsPar $2 }
| '(' exp ',' texps ')' { ExplicitTuple ($2 : reverse $4) Boxed}
| '(#' texps '#)' { ExplicitTuple (reverse $2) Unboxed }
| '_' { EWildPat }
-- MetaHaskell Extension
- | ID_SPLICE { mkHsSplice (HsVar (mkUnqual varName $1))} -- $x
- | '$(' exp ')' { mkHsSplice $2 } -- $( exp )
- | '[|' exp '|]' { HsBracket (ExpBr $2) }
- | '[t|' ctype '|]' { HsBracket (TypBr $2) }
- | '[p|' srcloc infixexp '|]' {% checkPattern $2 $3 `thenP` \p ->
- returnP (HsBracket (PatBr p)) }
- | '[d|' cvtopdecls '|]' { HsBracket (DecBr (mkGroup $2)) }
-
+ | srcloc TH_ID_SPLICE { mkHsSplice (HsVar (mkUnqual varName $2)) $1 } -- $x
+ | srcloc '$(' exp ')' { mkHsSplice $3 $1 } -- $( exp )
+ | srcloc TH_VAR_QUOTE qvar { HsBracket (VarBr $3) $1 }
+ | srcloc TH_VAR_QUOTE qcon { HsBracket (VarBr $3) $1 }
+ | srcloc TH_TY_QUOTE tyvar { HsBracket (VarBr $3) $1 }
+ | srcloc TH_TY_QUOTE gtycon { HsBracket (VarBr $3) $1 }
+ | srcloc '[|' exp '|]' { HsBracket (ExpBr $3) $1 }
+ | srcloc '[t|' ctype '|]' { HsBracket (TypBr $3) $1 }
+ | srcloc '[p|' infixexp '|]' {% checkPattern $1 $3 >>= \p ->
+ return (HsBracket (PatBr p) $1) }
+ | srcloc '[d|' cvtopbody '|]' { HsBracket (DecBr (mkGroup $3)) $1 }
+
+ -- arrow notation extension
+ | srcloc '(|' aexp2 cmdargs '|)'
+ { HsArrForm $3 Nothing (reverse $4) $1 }
+
+cmdargs :: { [RdrNameHsCmdTop] }
+ : cmdargs acmd { $2 : $1 }
+ | {- empty -} { [] }
+
+acmd :: { RdrNameHsCmdTop }
+ : aexp2 { HsCmdTop $1 [] placeHolderType undefined }
+
+cvtopbody :: { [RdrNameHsDecl] }
+ : '{' cvtopdecls '}' { $2 }
+ | vocurly cvtopdecls close { $2 }
texps :: { [RdrNameHsExpr] }
: texps ',' exp { $3 : $1 }
| exp ',' exp '..' { ArithSeqIn (FromThen $1 $3) }
| exp '..' exp { ArithSeqIn (FromTo $1 $3) }
| exp ',' exp '..' exp { ArithSeqIn (FromThenTo $1 $3 $5) }
- | exp srcloc pquals {% let { body [qs] = qs;
- body qss = [ParStmt (map reverse qss)] }
- in
- returnP ( mkHsDo ListComp
- (reverse (ResultStmt $1 $2 : body $3))
- $2
- )
+ | exp srcloc pquals { mkHsDo ListComp
+ (reverse (ResultStmt $1 $2 : $3))
+ $2
}
lexps :: { [RdrNameHsExpr] }
-----------------------------------------------------------------------------
-- List Comprehensions
-pquals :: { [[RdrNameStmt]] }
- : pquals '|' quals { $3 : $1 }
+pquals :: { [RdrNameStmt] } -- Either a singleton ParStmt, or a reversed list of Stmts
+ : pquals1 { case $1 of
+ [qs] -> qs
+ qss -> [ParStmt stmtss]
+ where
+ stmtss = [ (reverse qs, undefined)
+ | qs <- qss ]
+ }
+
+pquals1 :: { [[RdrNameStmt]] }
+ : pquals1 '|' quals { $3 : $1 }
| '|' quals { [$2] }
quals :: { [RdrNameStmt] }
- : quals ',' stmt { $3 : $1 }
- | stmt { [$1] }
+ : quals ',' qual { $3 : $1 }
+ | qual { [$1] }
-----------------------------------------------------------------------------
-- Parallel array expressions
(reverse $1) }
| exp '..' exp { PArrSeqIn (FromTo $1 $3) }
| exp ',' exp '..' exp { PArrSeqIn (FromThenTo $1 $3 $5) }
- | exp srcloc pquals {% let {
- body [qs] = qs;
- body qss = [ParStmt
- (map reverse qss)]}
- in
- returnP $
- mkHsDo PArrComp
- (reverse (ResultStmt $1 $2
- : body $3))
- $2
+ | exp srcloc pquals { mkHsDo PArrComp
+ (reverse (ResultStmt $1 $2 : $3))
+ $2
}
-- We are reusing `lexps' and `pquals' from the list case.
altslist :: { [RdrNameMatch] }
: '{' alts '}' { reverse $2 }
- | layout_on alts close { reverse $2 }
+ | vocurly alts close { reverse $2 }
alts :: { [RdrNameMatch] }
: alts1 { $1 }
alt :: { RdrNameMatch }
: srcloc infixexp opt_sig ralt wherebinds
- {% (checkPattern $1 $2 `thenP` \p ->
- returnP (Match [p] $3
+ {% (checkPattern $1 $2 >>= \p ->
+ return (Match [p] $3
(GRHSs $4 $5 placeHolderType)) )}
ralt :: { [RdrNameGRHS] }
-- Statement sequences
stmtlist :: { [RdrNameStmt] }
- : '{' stmts '}' { $2 }
- | layout_on_for_do stmts close { $2 }
+ : '{' stmts '}' { $2 }
+ | vocurly stmts close { $2 }
-- do { ;; s ; s ; ; s ;; }
-- The last Stmt should be a ResultStmt, but that's hard to enforce
| {- nothing -} { Nothing }
stmt :: { RdrNameStmt }
- : srcloc infixexp '<-' exp {% checkPattern $1 $2 `thenP` \p ->
- returnP (BindStmt p $4 $1) }
+ : qual { $1 }
+ | srcloc infixexp '->' exp {% checkPattern $1 $4 >>= \p ->
+ return (BindStmt p $2 $1) }
+ | srcloc 'rec' stmtlist { RecStmt $3 undefined undefined undefined }
+
+qual :: { RdrNameStmt }
+ : srcloc infixexp '<-' exp {% checkPattern $1 $2 >>= \p ->
+ return (BindStmt p $4 $1) }
| srcloc exp { ExprStmt $2 placeHolderType $1 }
- | srcloc 'let' decllist { LetStmt (cvBinds $3) }
+ | srcloc 'let' binds { LetStmt $3 }
-----------------------------------------------------------------------------
-- Record Field Update/Construction
-----------------------------------------------------------------------------
-- Implicit Parameter Bindings
-dbinding :: { [(IPName RdrName, RdrNameHsExpr)] }
- : '{' dbinds '}' { $2 }
- | layout_on dbinds close { $2 }
-
dbinds :: { [(IPName RdrName, RdrNameHsExpr)] }
: dbinds ';' dbind { $3 : $1 }
| dbinds ';' { $1 }
| tycon { $1 }
gcon :: { RdrName } -- Data constructor namespace
- : sysdcon { $1 }
+ : sysdcon { nameRdrName (dataConName $1) }
| qcon { $1 }
-- the case of '[:' ':]' is part of the production `parr'
-sysdcon :: { RdrName } -- Data constructor namespace
- : '(' ')' { getRdrName unitDataCon }
- | '(' commas ')' { getRdrName (tupleCon Boxed $2) }
- | '[' ']' { nameRdrName nilDataConName }
+sysdcon :: { DataCon } -- Wired in data constructors
+ : '(' ')' { unitDataCon }
+ | '(' commas ')' { tupleCon Boxed $2 }
+ | '[' ']' { nilDataCon }
var :: { RdrName }
: varid { $1 }
: oqtycon { $1 }
| '(' ')' { getRdrName unitTyCon }
| '(' commas ')' { getRdrName (tupleTyCon Boxed $2) }
- | '(' '->' ')' { nameRdrName funTyConName }
- | '[' ']' { nameRdrName listTyConName }
- | '[:' ':]' { nameRdrName parrTyConName }
+ | '(' '->' ')' { getRdrName funTyCon }
+ | '[' ']' { listTyCon_RDR }
+ | '[:' ':]' { parrTyCon_RDR }
oqtycon :: { RdrName } -- An "ordinary" qualified tycon
: qtycon { $1 }
consym :: { RdrName }
: CONSYM { mkUnqual dataName $1 }
- | ':' { nameRdrName consDataConName }
+
-- ':' means only list cons
+ | ':' { consDataCon_RDR }
-----------------------------------------------------------------------------
-- Literals
literal :: { HsLit }
- : CHAR { HsChar $1 }
+ : CHAR { HsChar (ord $1) } --TODO remove ord
| STRING { HsString $1 }
| PRIMINTEGER { HsIntPrim $1 }
- | PRIMCHAR { HsCharPrim $1 }
+ | PRIMCHAR { HsCharPrim (ord $1) } --TODO remove ord
| PRIMSTRING { HsStringPrim $1 }
| PRIMFLOAT { HsFloatPrim $1 }
| PRIMDOUBLE { HsDoublePrim $1 }
- | CLITLIT { HsLitLit $1 placeHolderType }
-srcloc :: { SrcLoc } : {% getSrcLocP }
-
+srcloc :: { SrcLoc } : {% getSrcLoc }
+
-----------------------------------------------------------------------------
-- Layout
: vccurly { () } -- context popped in lexer.
| error {% popContext }
-layout_on :: { () } : {% layoutOn True{-strict-} }
-layout_on_for_do :: { () } : {% layoutOn False }
-
-----------------------------------------------------------------------------
-- Miscellaneous (mostly renamings)
{
happyError :: P a
-happyError buf PState{ loc = loc } = PFailed (srcParseErr buf loc)
+happyError = srcParseFail
}
projects / ghc-hetmet.git / blobdiff