{- -*-haskell-*-
-----------------------------------------------------------------------------
-$Id: Parser.y,v 1.89 2002/02/13 15:19:19 simonpj Exp $
+$Id: Parser.y,v 1.100 2002/06/07 07:16:05 chak Exp $
Haskell grammar.
-}
{
-module Parser ( parseModule, parseStmt, parseIdentifier ) where
+module Parser ( parseModule, parseStmt, parseIdentifier, parseIface ) where
import HsSyn
import HsTypes ( mkHsTupCon )
import RdrHsSyn
+import RnMonad ( ParsedIface(..) )
import Lex
import ParseUtil
import RdrName
import TyCon ( DataConDetails(..) )
import SrcLoc ( SrcLoc )
import Module
-import CmdLineOpts ( opt_SccProfilingOn )
+import CmdLineOpts ( opt_SccProfilingOn, opt_InPackage )
import Type ( Kind, mkArrowKind, liftedTypeKind )
import BasicTypes ( Boxity(..), Fixity(..), FixityDirection(..), IPName(..),
NewOrData(..), StrictnessMark(..), Activation(..) )
-----------------------------------------------------------------------------
Conflicts: 21 shift/reduce, -=chak[4Feb2]
-9 for abiguity in 'if x then y else z + 1'
+11 for abiguity in 'if x then y else z + 1' [State 128]
(shift parses as 'if x then y else (z + 1)', as per longest-parse rule)
8 because op might be: - ! * . `x` VARSYM CONSYM QVARSYM QCONSYM
-1 for ambiguity in 'if x then y else z :: T'
- (shift parses as 'if x then y else (z :: T)', as per longest-parse rule)
-1 for ambiguity in 'if x then y else z with ?x=3'
- (shift parses as 'if x then y else (z with ?x=3)'
-3 for ambiguity in 'case x of y :: a -> b'
- (don't know whether to reduce 'a' as a btype or shift the '->'.
- conclusion: bogus expression anyway, doesn't matter)
+1 for ambiguity in '{-# RULES "name" [ ... #-} [State 210]
+ we don't know whether the '[' starts the activation or not: it
+ might be the start of the declaration with the activation being
+ empty. --SDM 1/4/2002
-1 for ambiguity in '{-# RULES "name" forall = ... #-}'
+1 for ambiguity in '{-# RULES "name" forall = ... #-}' [State 412]
since 'forall' is a valid variable name, we don't know whether
to treat a forall on the input as the beginning of a quantifier
or the beginning of the rule itself. Resolving to shift means
This saves explicitly defining a grammar for the rule lhs that
doesn't include 'forall'.
-1 for ambiguity in 'x @ Rec{..}'.
- Only sensible parse is 'x @ (Rec{..})', which is what resolving
- to shift gives us.
+1 for ambiguity in 'let ?x ...' [State 278]
+ the parser can't tell whether the ?x is the lhs of a normal binding or
+ an implicit binding. Fortunately resolving as shift gives it the only
+ sensible meaning, namely the lhs of an implicit binding.
+
+
+8 for ambiguity in 'e :: a `b` c'. Does this mean [States 238,267]
+ (e::a) `b` c, or
+ (e :: (a `b` c))
+
+6 for conflicts between `fdecl' and `fdeclDEPRECATED', [States 402,403]
+ which are resolved correctly, and moreover,
+ should go away when `fdeclDEPRECATED' is removed.
+
+1 for ambiguity in 'if x then y else z :: T'
+ (shift parses as 'if x then y else (z :: T)', as per longest-parse rule)
+1 for ambiguity in 'if x then y else z with ?x=3'
+ (shift parses as 'if x then y else (z with ?x=3)'
+3 for ambiguity in 'case x of y :: a -> b'
+ (don't know whether to reduce 'a' as a btype or shift the '->'.
+ conclusion: bogus expression anyway, doesn't matter)
-6 for conflicts between `fdecl' and `fdeclDEPRECATED', which are resolved
- correctly, and moreover, should go away when `fdeclDEPRECATED' is removed.
-----------------------------------------------------------------------------
-}
'label' { ITlabel }
'dynamic' { ITdynamic }
'safe' { ITsafe }
+ 'threadsafe' { ITthreadsafe }
'unsafe' { ITunsafe }
'with' { ITwith }
'stdcall' { ITstdcallconv }
'ccall' { ITccallconv }
'dotnet' { ITdotnet }
'_ccall_' { ITccall (False, False, PlayRisky) }
- '_ccall_GC_' { ITccall (False, False, PlaySafe) }
+ '_ccall_GC_' { ITccall (False, False, PlaySafe False) }
'_casm_' { ITccall (False, True, PlayRisky) }
- '_casm_GC_' { ITccall (False, True, PlaySafe) }
+ '_casm_GC_' { ITccall (False, True, PlaySafe False) }
'{-# SPECIALISE' { ITspecialise_prag }
'{-# SOURCE' { ITsource_prag }
%name parseModule module
%name parseStmt maybe_stmt
%name parseIdentifier identifier
+%name parseIface iface
%tokentype { Token }
%%
: topdecls { cvTopDecls (groupBindings $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] }
+ : '{' ifacedecls '}' { $2 }
+ | layout_on ifacedecls close { $2 }
+
+ifacedecls :: { [RdrNameTyClDecl] }
+ : ifacedecl ';' ifacedecls { $1 : $3 }
+ | ';' ifacedecls { $2 }
+ | ifacedecl { [$1] }
+ | {- empty -} { [] }
+
+ifacedecl :: { RdrNameTyClDecl }
+ : srcloc 'data' tycl_hdr constrs
+ { mkTyData DataType $3 (DataCons (reverse $4)) Nothing $1 }
+
+ | srcloc 'newtype' tycl_hdr '=' newconstr
+ { mkTyData NewType $3 (DataCons [$5]) Nothing $1 }
+
+ | srcloc 'class' tycl_hdr fds where
+ { let
+ (binds,sigs) = cvMonoBindsAndSigs cvClassOpSig
+ (groupBindings $5)
+ in
+ mkClassDecl $3 $4 sigs (Just binds) $1 }
+
+ | srcloc 'type' tycon tv_bndrs '=' ctype
+ { TySynonym $3 $4 $6 $1 }
+
+ | srcloc var '::' sigtype
+ { IfaceSig $2 $4 [] $1 }
+
+-----------------------------------------------------------------------------
-- The Export List
maybeexports :: { Maybe [RdrNameIE] }
| topdecl { [$1] }
topdecl :: { RdrBinding }
- : srcloc 'type' tycon tv_bndrs '=' ctype
+ : srcloc 'type' syn_hdr '=' ctype
-- Note ctype, not sigtype.
-- We allow an explicit for-all but we don't insert one
-- in type Foo a = (b,b)
-- Instead we just say b is out of scope
- { RdrHsDecl (TyClD (TySynonym $3 $4 $6 $1)) }
+ { let (tc,tvs) = $3
+ in RdrHsDecl (TyClD (TySynonym tc tvs $5 $1)) }
| srcloc 'data' tycl_hdr constrs deriving
| '{-# RULES' rules '#-}' { $2 }
| decl { $1 }
+syn_hdr :: { (RdrName, [RdrNameHsTyVar]) } -- We don't retain the syntax of an infix
+ -- type synonym declaration. Oh well.
+ : tycon tv_bndrs { ($1, $2) }
+ | tv_bndr tyconop tv_bndr { ($2, [$1,$3]) }
+
-- tycl_hdr parses the header of a type or class decl,
-- which takes the form
-- T a b
-- (Eq a, Ord b) => T a b
-- Rather a lot of inlining here, else we get reduce/reduce errors
tycl_hdr :: { (RdrNameContext, RdrName, [RdrNameHsTyVar]) }
- : '(' comma_types1 ')' '=>' gtycon tv_bndrs {% mapP checkPred $2 `thenP` \ cxt ->
- returnP (cxt, $5, $6) }
+ : context '=>' type {% checkTyClHdr $3 `thenP` \ (tc,tvs) ->
+ returnP ($1, tc, tvs) }
+ | type {% checkTyClHdr $1 `thenP` \ (tc,tvs) ->
+ returnP ([], tc, tvs) }
+
+{-
+ : '(' comma_types1 ')' '=>' gtycon tv_bndrs
+ {% mapP checkPred $2 `thenP` \ cxt ->
+ returnP (cxt, $5, $6) }
+
+ | '(' ')' '=>' gtycon tv_bndrs
+ { ([], $4, $5) }
+
-- qtycon for the class below name would lead to many s/r conflicts
-- FIXME: does the renamer pick up all wrong forms and raise an
-- error
- | gtycon atypes1 '=>' gtycon atypes0 {% checkTyVars $5 `thenP` \ tvs ->
- returnP ([HsClassP $1 $2], $4, tvs) }
- | gtycon atypes0 {% checkTyVars $2 `thenP` \ tvs ->
- returnP ([], $1, tvs) }
+ | gtycon atypes1 '=>' gtycon atypes0
+ {% checkTyVars $5 `thenP` \ tvs ->
+ returnP ([HsClassP $1 $2], $4, tvs) }
+
+ | gtycon atypes0
+ {% checkTyVars $2 `thenP` \ tvs ->
+ returnP ([], $1, tvs) }
-- We have to have qtycon in this production to avoid s/r
-- conflicts with the previous one. The renamer will complain
-- if we use a qualified tycon.
-- an error in the renamer if some non-H98 form is used and
-- -fglasgow-exts is not given.) -=chak
+atypes0 :: { [RdrNameHsType] }
+ : atypes1 { $1 }
+ | {- empty -} { [] }
+
+atypes1 :: { [RdrNameHsType] }
+ : atype { [$1] }
+ | atype atypes1 { $1 : $2 }
+-}
+
decls :: { [RdrBinding] }
: decls ';' decl { $3 : $1 }
| decls ';' { $1 }
: '{' decls '}' { $2 }
| layout_on decls close { $2 }
+letbinds :: { RdrNameHsExpr -> RdrNameHsExpr }
+ : decllist { HsLet (cvBinds cvValSig (groupBindings $1)) }
+ | '{' dbinds '}' { \e -> HsWith e $2 False{-not with-} }
+ | layout_on dbinds close { \e -> HsWith e $2 False{-not with-} }
+
fixdecl :: { RdrBinding }
: srcloc infix prec ops { foldr1 RdrAndBindings
[ RdrSig (FixSig (FixitySig n
--
fdecl :: { RdrNameHsDecl }
fdecl : srcloc 'import' callconv safety1 fspec {% mkImport $3 $4 $5 $1 }
- | srcloc 'import' callconv fspec {% mkImport $3 PlaySafe $4 $1 }
+ | srcloc 'import' callconv fspec {% mkImport $3 (PlaySafe False) $4 $1 }
| srcloc 'export' callconv fspec {% mkExport $3 $4 $1 }
-- the following syntax is DEPRECATED
| srcloc fdecl1DEPRECATED { ForD ($2 True $1) }
fdecl1DEPRECATED
----------- DEPRECATED label decls ------------
: 'label' ext_name varid '::' sigtype
- { ForeignImport $3 $5 (CImport defaultCCallConv PlaySafe _NIL_ _NIL_
+ { ForeignImport $3 $5 (CImport defaultCCallConv (PlaySafe False) nilFS nilFS
(CLabel ($2 `orElse` mkExtName $3))) }
----------- DEPRECATED ccall/stdcall decls ------------
{ let
target = StaticTarget ($2 `orElse` mkExtName $4)
in
- ForeignImport $4 $6 (CImport defaultCCallConv $3 _NIL_ _NIL_
+ ForeignImport $4 $6 (CImport defaultCCallConv $3 nilFS nilFS
(CFunction target)) }
-- DEPRECATED variant #2: external name consists of two separate strings
let
imp = CFunction (StaticTarget $4)
in
- ForeignImport $6 $8 (CImport cconv $5 _NIL_ _NIL_ imp) }
+ ForeignImport $6 $8 (CImport cconv $5 nilFS nilFS imp) }
-- DEPRECATED variant #3: `unsafe' after entity
| 'import' callconv STRING 'unsafe' varid_no_unsafe '::' sigtype
let
imp = CFunction (StaticTarget $3)
in
- ForeignImport $5 $7 (CImport cconv PlayRisky _NIL_ _NIL_ imp) }
+ ForeignImport $5 $7 (CImport cconv PlayRisky nilFS nilFS imp) }
-- DEPRECATED variant #4: use of the special identifier `dynamic' without
-- an explicit calling convention (import)
| 'import' {-no callconv-} 'dynamic' safety varid_no_unsafe '::' sigtype
- { ForeignImport $4 $6 (CImport defaultCCallConv $3 _NIL_ _NIL_
+ { ForeignImport $4 $6 (CImport defaultCCallConv $3 nilFS nilFS
(CFunction DynamicTarget)) }
-- DEPRECATED variant #5: use of the special identifier `dynamic' (import)
{% case $2 of
DNCall -> parseError "Illegal format of .NET foreign import"
CCall cconv -> returnP $
- ForeignImport $5 $7 (CImport cconv $4 _NIL_ _NIL_
+ ForeignImport $5 $7 (CImport cconv $4 nilFS nilFS
(CFunction DynamicTarget)) }
-- DEPRECATED variant #6: lack of a calling convention specification
-- DEPRECATED variant #8: use of the special identifier `dynamic' without
-- an explicit calling convention (export)
| 'export' {-no callconv-} 'dynamic' varid '::' sigtype
- { ForeignImport $3 $5 (CImport defaultCCallConv PlaySafe _NIL_ _NIL_
+ { ForeignImport $3 $5 (CImport defaultCCallConv (PlaySafe False) nilFS nilFS
CWrapper) }
-- DEPRECATED variant #9: use of the special identifier `dynamic' (export)
{% case $2 of
DNCall -> parseError "Illegal format of .NET foreign import"
CCall cconv -> returnP $
- ForeignImport $4 $6 (CImport cconv PlaySafe _NIL_ _NIL_ CWrapper) }
+ ForeignImport $4 $6 (CImport cconv (PlaySafe False) nilFS nilFS CWrapper) }
----------- DEPRECATED .NET decls ------------
-- NB: removed the .NET call declaration, as it is entirely subsumed
safety :: { Safety }
: 'unsafe' { PlayRisky }
- | 'safe' { PlaySafe }
- | {- empty -} { PlaySafe }
+ | 'safe' { PlaySafe False }
+ | 'threadsafe' { PlaySafe True }
+ | {- empty -} { PlaySafe False }
safety1 :: { Safety }
: 'unsafe' { PlayRisky }
- | 'safe' { PlaySafe }
+ | 'safe' { PlaySafe False }
+ | 'threadsafe' { PlaySafe True }
-- only needed to avoid conflicts with the DEPRECATED rules
-fspec :: { (FAST_STRING, RdrName, RdrNameHsType) }
+fspec :: { (FastString, RdrName, RdrNameHsType) }
: STRING varid '::' sigtype { ($1 , $2, $4) }
- | varid '::' sigtype { (SLIT(""), $1, $3) }
+ | varid '::' sigtype { (nilFS, $1, $3) }
-- if the entity string is missing, it defaults to the empty string;
-- the meaning of an empty entity string depends on the calling
-- convention
: btype {% checkContext $1 }
type :: { RdrNameHsType }
- : gentype '->' type { HsFunTy $1 $3 }
- | ipvar '::' type { mkHsIParamTy $1 $3 }
+ : ipvar '::' gentype { mkHsIParamTy $1 $3 }
| gentype { $1 }
gentype :: { RdrNameHsType }
: btype { $1 }
--- Generics
- | atype tyconop atype { HsOpTy $1 $2 $3 }
+ | btype qtyconop gentype { HsOpTy $1 (HsTyOp $2) $3 }
+ | btype '->' gentype { HsOpTy $1 HsArrow $3 }
btype :: { RdrNameHsType }
: btype atype { HsAppTy $1 $2 }
| tyvar { HsTyVar $1 }
| '(' type ',' comma_types1 ')' { HsTupleTy (mkHsTupCon tcName Boxed ($2:$4)) ($2:$4) }
| '(#' comma_types1 '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) $2 }
- | '[' type ']' { HsListTy $2 }
- | '[:' type ':]' { HsPArrTy $2 }
- | '(' ctype ')' { $2 }
+ | '[' type ']' { HsListTy $2 }
+ | '[:' type ':]' { HsPArrTy $2 }
+ | '(' ctype ')' { HsParTy $2 }
| '(' ctype '::' kind ')' { HsKindSig $2 $4 }
-- Generics
| INTEGER { HsNumTy $1 }
: type { [$1] }
| type ',' comma_types1 { $1 : $3 }
-atypes0 :: { [RdrNameHsType] }
- : atypes1 { $1 }
- | {- empty -} { [] }
-
-atypes1 :: { [RdrNameHsType] }
- : atype { [$1] }
- | atype atypes1 { $1 : $2 }
-
tv_bndrs :: { [RdrNameHsTyVar] }
: tv_bndr tv_bndrs { $1 : $2 }
| {- empty -} { [] }
exp :: { RdrNameHsExpr }
: infixexp '::' sigtype { (ExprWithTySig $1 $3) }
- | infixexp 'with' dbinding { HsWith $1 $3 }
+ | infixexp 'with' dbinding { HsWith $1 $3 True{-not a let-} }
| infixexp { $1 }
infixexp :: { RdrNameHsExpr }
returnP (HsLam (Match ps $5
(GRHSs (unguardedRHS $8 $7)
EmptyBinds placeHolderType))) }
- | 'let' declbinds 'in' exp { HsLet $2 $4 }
+ | 'let' letbinds 'in' exp { $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 (HsDo DoExpr stmts $1) }
+ returnP (mkHsDo DoExpr stmts $1) }
| '_ccall_' ccallid aexps0 { HsCCall $2 $3 PlayRisky False placeHolderType }
- | '_ccall_GC_' ccallid aexps0 { HsCCall $2 $3 PlaySafe 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 True placeHolderType }
+ | '_casm_GC_' CLITLIT aexps0 { HsCCall $2 $3 (PlaySafe False) True placeHolderType }
| scc_annot exp { if opt_SccProfilingOn
then HsSCC $1 $2
| fexp { $1 }
-scc_annot :: { FAST_STRING }
+scc_annot :: { FastString }
: '_scc_' STRING { $2 }
| '{-# SCC' STRING '#-}' { $2 }
-ccallid :: { FAST_STRING }
+ccallid :: { FastString }
: VARID { $1 }
| CONID { $1 }
| {- empty -} { [] }
aexp :: { RdrNameHsExpr }
- : var_or_con '{|' gentype '|}' { (HsApp $1 (HsType $3)) }
- | aexp '{' fbinds '}' {% (mkRecConstrOrUpdate $1
+ : qvar '@' aexp { EAsPat $1 $3 }
+ | '~' aexp { ELazyPat $2 }
+ | aexp1 { $1 }
+
+aexp1 :: { RdrNameHsExpr }
+ : aexp1 '{' fbinds '}' {% (mkRecConstrOrUpdate $1
(reverse $3)) }
- | aexp1 { $1 }
+ | aexp2 { $1 }
+ | var_or_con '{|' gentype '|}' { HsApp $1 (HsType $3) }
+
var_or_con :: { RdrNameHsExpr }
: qvar { HsVar $1 }
| gcon { HsVar $1 }
-aexp1 :: { RdrNameHsExpr }
+aexp2 :: { RdrNameHsExpr }
: ipvar { HsIPVar $1 }
| var_or_con { $1 }
| literal { HsLit $1 }
| '[:' parr ':]' { $2 }
| '(' infixexp qop ')' { (SectionL $2 (HsVar $3)) }
| '(' qopm infixexp ')' { (SectionR $2 $3) }
- | qvar '@' aexp { EAsPat $1 $3 }
| '_' { EWildPat }
- | '~' aexp1 { ELazyPat $2 }
texps :: { [RdrNameHsExpr] }
: texps ',' exp { $3 : $1 }
| exp srcloc pquals {% let { body [qs] = qs;
body qss = [ParStmt (map reverse qss)] }
in
- returnP ( HsDo ListComp
- (reverse (ResultStmt $1 $2 : body $3))
- $2
+ returnP ( mkHsDo ListComp
+ (reverse (ResultStmt $1 $2 : body $3))
+ $2
)
}
(map reverse qss)]}
in
returnP $
- HsDo PArrComp
- (reverse (ResultStmt $1 $2
- : body $3))
- $2
+ mkHsDo PArrComp
+ (reverse (ResultStmt $1 $2
+ : body $3))
+ $2
}
-- We are reusing `lexps' and `pquals' from the list case.
: dbinds ';' dbind { $3 : $1 }
| dbinds ';' { $1 }
| dbind { [$1] }
- | {- empty -} { [] }
+-- | {- empty -} { [] }
dbind :: { (IPName RdrName, RdrNameHsExpr) }
dbind : ipvar '=' exp { ($1, $3) }
| '`' qconid '`' { $2 }
-----------------------------------------------------------------------------
+-- Type constructors
+
+tycon :: { RdrName } -- Unqualified
+ : CONID { mkUnqual tcClsName $1 }
+
+tyconop :: { RdrName } -- Unqualified
+ : CONSYM { mkUnqual tcClsName $1 }
+ | '`' tyvar '`' { $2 }
+ | '`' tycon '`' { $2 }
+
+qtycon :: { RdrName } -- Qualified or unqualified
+ : QCONID { mkQual tcClsName $1 }
+ | tycon { $1 }
+
+qtyconop :: { RdrName } -- Qualified or unqualified
+ : QCONSYM { mkQual tcClsName $1 }
+ | '`' QCONID '`' { mkQual tcClsName $2 }
+ | tyconop { $1 }
+
+-----------------------------------------------------------------------------
-- Any operator
op :: { RdrName } -- used in infix decls
varid :: { RdrName }
: varid_no_unsafe { $1 }
- | 'unsafe' { mkUnqual varName SLIT("unsafe") }
+ | 'unsafe' { mkUnqual varName FSLIT("unsafe") }
+ | 'safe' { mkUnqual varName FSLIT("safe") }
+ | 'threadsafe' { mkUnqual varName FSLIT("threadsafe") }
varid_no_unsafe :: { RdrName }
: VARID { mkUnqual varName $1 }
| special_id { mkUnqual varName $1 }
- | 'forall' { mkUnqual varName SLIT("forall") }
+ | 'forall' { mkUnqual varName FSLIT("forall") }
tyvar :: { RdrName }
: VARID { mkUnqual tvName $1 }
| special_id { mkUnqual tvName $1 }
- | 'unsafe' { mkUnqual tvName SLIT("unsafe") }
+ | 'unsafe' { mkUnqual tvName FSLIT("unsafe") }
+ | 'safe' { mkUnqual tvName FSLIT("safe") }
+ | 'threadsafe' { mkUnqual tvName FSLIT("threadsafe") }
-- These special_ids are treated as keywords in various places,
--- but as ordinary ids elsewhere. A special_id collects all thsee
+-- but as ordinary ids elsewhere. 'special_id' collects all these
-- except 'unsafe' and 'forall' whose treatment differs depending on context
special_id :: { UserFS }
special_id
- : 'as' { SLIT("as") }
- | 'qualified' { SLIT("qualified") }
- | 'hiding' { SLIT("hiding") }
- | 'export' { SLIT("export") }
- | 'label' { SLIT("label") }
- | 'dynamic' { SLIT("dynamic") }
- | 'stdcall' { SLIT("stdcall") }
- | 'ccall' { SLIT("ccall") }
-
------------------------------------------------------------------------------
--- ConIds
-
-qconid :: { RdrName } -- Qualified or unqualifiedb
- : conid { $1 }
- | QCONID { mkQual dataName $1 }
-
-conid :: { RdrName }
- : CONID { mkUnqual dataName $1 }
-
------------------------------------------------------------------------------
--- ConSyms
-
-qconsym :: { RdrName } -- Qualified or unqualifiedb
- : consym { $1 }
- | QCONSYM { mkQual dataName $1 }
-
-consym :: { RdrName }
- : CONSYM { mkUnqual dataName $1 }
+ : 'as' { FSLIT("as") }
+ | 'qualified' { FSLIT("qualified") }
+ | 'hiding' { FSLIT("hiding") }
+ | 'export' { FSLIT("export") }
+ | 'label' { FSLIT("label") }
+ | 'dynamic' { FSLIT("dynamic") }
+ | 'stdcall' { FSLIT("stdcall") }
+ | 'ccall' { FSLIT("ccall") }
-----------------------------------------------------------------------------
--- VarSyms
+-- Variables
qvarsym :: { RdrName }
: varsym { $1 }
varsym :: { RdrName }
: varsym_no_minus { $1 }
- | '-' { mkUnqual varName SLIT("-") }
+ | '-' { mkUnqual varName FSLIT("-") }
varsym_no_minus :: { RdrName } -- varsym not including '-'
: VARSYM { mkUnqual varName $1 }
-- See comments with special_id
special_sym :: { UserFS }
-special_sym : '!' { SLIT("!") }
- | '.' { SLIT(".") }
- | '*' { SLIT("*") }
+special_sym : '!' { FSLIT("!") }
+ | '.' { FSLIT(".") }
+ | '*' { FSLIT("*") }
+
+-----------------------------------------------------------------------------
+-- Data constructors
+
+qconid :: { RdrName } -- Qualified or unqualifiedb
+ : conid { $1 }
+ | QCONID { mkQual dataName $1 }
+
+conid :: { RdrName }
+ : CONID { mkUnqual dataName $1 }
+
+qconsym :: { RdrName } -- Qualified or unqualified
+ : consym { $1 }
+ | QCONSYM { mkQual dataName $1 }
+
+consym :: { RdrName }
+ : CONSYM { mkUnqual dataName $1 }
+
-----------------------------------------------------------------------------
-- Literals
'.':unpackFS (snd $1)))
}
-tycon :: { RdrName }
- : CONID { mkUnqual tcClsName $1 }
-
-tyconop :: { RdrName }
- : CONSYM { mkUnqual tcClsName $1 }
-
-qtycon :: { RdrName } -- Qualified or unqualified
- : QCONID { mkQual tcClsName $1 }
- | tycon { $1 }
-
-qtyconop :: { RdrName } -- Qualified or unqualified
- : QCONSYM { mkQual tcClsName $1 }
- | tyconop { $1 }
-
commas :: { Int }
: commas ',' { $1 + 1 }
| ',' { 2 }