{-
-----------------------------------------------------------------------------
-$Id: Parser.y,v 1.42 2000/10/24 07:35:01 simonpj Exp $
+$Id: Parser.y,v 1.64 2001/05/18 08:46:20 simonpj Exp $
Haskell grammar.
-}
{
-module Parser ( parse ) where
+module Parser ( parseModule, parseStmt ) where
import HsSyn
-import HsPragmas
import HsTypes ( mkHsTupCon )
-import HsPat ( InPat(..) )
import RdrHsSyn
import Lex
import ParseUtil
import RdrName
-import PrelInfo ( mAIN_Name )
-import OccName ( UserFS, varName, ipName, tcName, dataName, tcClsName, tvName )
+import PrelNames ( mAIN_Name, unitTyCon_RDR, funTyCon_RDR, listTyCon_RDR,
+ tupleTyCon_RDR, unitCon_RDR, nilCon_RDR, tupleCon_RDR
+ )
+import OccName ( UserFS, varName, tcName, dataName, tcClsName, tvName )
import SrcLoc ( SrcLoc )
import Module
import CallConv
+import Demand ( StrictnessMark(..) )
import CmdLineOpts ( opt_SccProfilingOn )
import BasicTypes ( Boxity(..), Fixity(..), FixityDirection(..), NewOrData(..) )
import Panic
'then' { ITthen }
'type' { ITtype }
'where' { ITwhere }
- '_scc_' { ITscc }
+ '_scc_' { ITscc } -- ToDo: remove
'forall' { ITforall } -- GHC extension keywords
'foreign' { ITforeign }
'{-# INLINE' { ITinline_prag }
'{-# NOINLINE' { ITnoinline_prag }
'{-# RULES' { ITrules_prag }
+ '{-# SCC' { ITscc_prag }
'{-# DEPRECATED' { ITdeprecated_prag }
'#-}' { ITclose_prag }
%monad { P } { thenP } { returnP }
%lexer { lexer } { ITeof }
-%name parse
+%name parseModule module
+%name parseStmt maybe_stmt
%tokentype { Token }
%%
importdecl :: { RdrNameImportDecl }
: 'import' srcloc maybe_src optqualified CONID maybeas maybeimpspec
- { ImportDecl (mkSrcModuleFS $5) $3 $4 $6 $7 $2 }
+ { ImportDecl (mkModuleNameFS $5) $3 $4 $6 $7 $2 }
maybe_src :: { WhereFrom }
: '{-# SOURCE' '#-}' { ImportByUserSource }
| topdecl { [$1] }
topdecl :: { RdrBinding }
- : srcloc 'type' simpletype '=' sigtype
+ : srcloc 'type' simpletype '=' 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 (fst $3) (snd $3) $5 $1)) }
| srcloc 'data' ctype '=' constrs deriving
{% checkDataHeader $3 `thenP` \(cs,c,ts) ->
returnP (RdrHsDecl (TyClD
- (mkTyData DataType cs c ts (reverse $5) (length $5) $6
- NoDataPragmas $1))) }
+ (mkTyData DataType cs c ts (reverse $5) (length $5) $6 $1))) }
| srcloc 'newtype' ctype '=' newconstr deriving
{% checkDataHeader $3 `thenP` \(cs,c,ts) ->
returnP (RdrHsDecl (TyClD
- (mkTyData NewType cs c ts [$5] 1 $6
- NoDataPragmas $1))) }
+ (mkTyData NewType cs c ts [$5] 1 $6 $1))) }
| srcloc 'class' ctype fds where
{% checkDataHeader $3 `thenP` \(cs,c,ts) ->
(binds,sigs) = cvMonoBindsAndSigs cvClassOpSig (groupBindings $5)
in
returnP (RdrHsDecl (TyClD
- (mkClassDecl cs c ts $4 sigs binds
- NoClassPragmas $1))) }
+ (mkClassDecl cs c ts $4 sigs (Just binds) $1))) }
| srcloc 'instance' inst_type where
{ let (binds,sigs)
decl :: { RdrBinding }
: fixdecl { $1 }
| valdef { $1 }
- | '{-# INLINE' srcloc opt_phase qvar '#-}' { RdrSig (InlineSig $4 $3 $2) }
- | '{-# NOINLINE' srcloc opt_phase qvar '#-}' { RdrSig (NoInlineSig $4 $3 $2) }
+ | '{-# INLINE' srcloc opt_phase qvar '#-}' { RdrSig (InlineSig $4 $3 $2) }
+ | '{-# NOINLINE' srcloc opt_phase qvar '#-}' { RdrSig (NoInlineSig $4 $3 $2) }
| '{-# SPECIALISE' srcloc qvar '::' sigtypes '#-}'
{ foldr1 RdrAndBindings
(map (\t -> RdrSig (SpecSig $3 t $2)) $5) }
| {- empty -} { RdrNullBind }
rule :: { RdrBinding }
- : STRING rule_forall fexp '=' srcloc exp
+ : STRING rule_forall infixexp '=' srcloc exp
{ RdrHsDecl (RuleD (HsRule $1 [] $2 $3 $6 $5)) }
rule_forall :: { [RdrNameRuleBndr] }
: ctype {% checkInstType $1 }
types0 :: { [RdrNameHsType] }
- : types { $1 }
+ : types { reverse $1 }
| {- empty -} { [] }
types :: { [RdrNameHsType] }
-- Datatype declarations
newconstr :: { RdrNameConDecl }
- : srcloc conid atype { mkConDecl $2 [] [] (VanillaCon [Unbanged $3]) $1 }
+ : srcloc conid atype { mkConDecl $2 [] [] (VanillaCon [unbangedType $3]) $1 }
| srcloc conid '{' var '::' type '}'
- { mkConDecl $2 [] [] (RecCon [([$4], Unbanged $6)]) $1 }
+ { mkConDecl $2 [] [] (RecCon [([$4], unbangedType $6)]) $1 }
constrs :: { [RdrNameConDecl] }
: constrs '|' constr { $3 : $1 }
constr_stuff :: { (RdrName, RdrNameConDetails) }
: btype {% mkVanillaCon $1 [] }
- | btype '!' atype satypes {% mkVanillaCon $1 (Banged $3 : $4) }
+ | btype '!' atype satypes {% mkVanillaCon $1 (BangType MarkedUserStrict $3 : $4) }
| gtycon '{' fielddecls '}' {% mkRecCon $1 $3 }
| sbtype conop sbtype { ($2, InfixCon $1 $3) }
satypes :: { [RdrNameBangType] }
- : atype satypes { Unbanged $1 : $2 }
- | '!' atype satypes { Banged $2 : $3 }
+ : atype satypes { unbangedType $1 : $2 }
+ | '!' atype satypes { BangType MarkedUserStrict $2 : $3 }
| {- empty -} { [] }
sbtype :: { RdrNameBangType }
- : btype { Unbanged $1 }
- | '!' atype { Banged $2 }
+ : btype { unbangedType $1 }
+ | '!' atype { BangType MarkedUserStrict $2 }
fielddecls :: { [([RdrName],RdrNameBangType)] }
: fielddecl ',' fielddecls { $1 : $3 }
: sig_vars '::' stype { (reverse $1, $3) }
stype :: { RdrNameBangType }
- : ctype { Unbanged $1 }
- | '!' atype { Banged $2 }
+ : ctype { unbangedType $1 }
+ | '!' atype { BangType MarkedUserStrict $2 }
deriving :: { Maybe [RdrName] }
: {- empty -} { Nothing }
| gdrh { [$1] }
gdrh :: { RdrNameGRHS }
- : '|' srcloc quals '=' exp { GRHS (reverse (ExprStmt $5 $2 : $3)) $2 }
+ : '|' srcloc quals '=' exp { GRHS (reverse (ResultStmt $5 $2 : $3)) $2 }
-----------------------------------------------------------------------------
-- Expressions
(panic "fixity") $3 )}
exp10 :: { RdrNameHsExpr }
- : '\\' aexp aexps opt_asig '->' srcloc exp
- {% checkPatterns ($2 : reverse $3) `thenP` \ ps ->
- returnP (HsLam (Match [] ps $4
- (GRHSs (unguardedRHS $7 $6)
+ : '\\' srcloc aexp aexps opt_asig '->' srcloc exp
+ {% checkPatterns $2 ($3 : reverse $4) `thenP` \ ps ->
+ returnP (HsLam (Match [] ps $5
+ (GRHSs (unguardedRHS $8 $7)
EmptyBinds Nothing))) }
| 'let' declbinds '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 { HsDo DoStmt $3 $1 }
+ | srcloc 'do' stmtlist {% checkDo $3 `thenP` \ stmts ->
+ returnP (HsDo DoExpr stmts $1) }
| '_ccall_' ccallid aexps0 { HsCCall $2 $3 False False cbot }
| '_ccall_GC_' ccallid aexps0 { HsCCall $2 $3 True False cbot }
| '_casm_' CLITLIT aexps0 { HsCCall $2 $3 False True cbot }
| '_casm_GC_' CLITLIT aexps0 { HsCCall $2 $3 True True cbot }
- | '_scc_' STRING exp { if opt_SccProfilingOn
- then HsSCC $2 $3
- else HsPar $3 }
+ | scc_annot exp { if opt_SccProfilingOn
+ then HsSCC $1 $2
+ else HsPar $2 }
| fexp { $1 }
+scc_annot :: { FAST_STRING }
+ : '_scc_' STRING { $2 }
+ | '{-# SCC' STRING '#-}' { $2 }
+
ccallid :: { FAST_STRING }
: VARID { $1 }
| CONID { $1 }
: ipvar { HsIPVar $1 }
| var_or_con { $1 }
| literal { HsLit $1 }
- | INTEGER { HsOverLit (mkHsIntegralLit $1) }
- | RATIONAL { HsOverLit (mkHsFractionalLit $1) }
+ | INTEGER { HsOverLit (HsIntegral $1) }
+ | RATIONAL { HsOverLit (HsFractional $1) }
| '(' exp ')' { HsPar $2 }
| '(' exp ',' texps ')' { ExplicitTuple ($2 : reverse $4) Boxed}
| '(#' texps '#)' { ExplicitTuple (reverse $2) Unboxed }
| exp ',' exp '..' { ArithSeqIn (FromThen $1 $3) }
| exp '..' exp { ArithSeqIn (FromTo $1 $3) }
| exp ',' exp '..' exp { ArithSeqIn (FromThenTo $1 $3 $5) }
- | exp srcloc '|' quals { HsDo ListComp (reverse
- (ReturnStmt $1 : $4)) $2 }
+ | exp srcloc pquals {% let { body [qs] = qs;
+ body qss = [ParStmt (map reverse qss)] }
+ in
+ returnP ( HsDo ListComp
+ (reverse (ResultStmt $1 $2 : body $3))
+ $2
+ )
+ }
lexps :: { [RdrNameHsExpr] }
: lexps ',' exp { $3 : $1 }
-----------------------------------------------------------------------------
-- List Comprehensions
-quals :: { [RdrNameStmt] }
- : quals ',' qual { $3 : $1 }
- | qual { [$1] }
+pquals :: { [[RdrNameStmt]] }
+ : pquals '|' quals { $3 : $1 }
+ | '|' quals { [$2] }
-qual :: { RdrNameStmt }
- : srcloc infixexp '<-' exp {% checkPattern $2 `thenP` \p ->
- returnP (BindStmt p $4 $1) }
- | srcloc exp { GuardStmt $2 $1 }
- | srcloc 'let' declbinds { LetStmt $3 }
+quals :: { [RdrNameStmt] }
+ : quals ',' stmt { $3 : $1 }
+ | stmt { [$1] }
-----------------------------------------------------------------------------
-- Case alternatives
| alt { [$1] }
alt :: { RdrNameMatch }
- : infixexp opt_sig ralt wherebinds
- {% (checkPattern $1 `thenP` \p ->
- returnP (Match [] [p] $2
- (GRHSs $3 $4 Nothing)) )}
+ : srcloc infixexp opt_sig ralt wherebinds
+ {% (checkPattern $1 $2 `thenP` \p ->
+ returnP (Match [] [p] $3
+ (GRHSs $4 $5 Nothing)) )}
ralt :: { [RdrNameGRHS] }
- : '->' srcloc exp { [GRHS [ExprStmt $3 $2] $2] }
+ : '->' srcloc exp { [GRHS [ResultStmt $3 $2] $2] }
| gdpats { (reverse $1) }
gdpats :: { [RdrNameGRHS] }
| gdpat { [$1] }
gdpat :: { RdrNameGRHS }
- : srcloc '|' quals '->' exp { GRHS (reverse (ExprStmt $5 $1:$3)) $1}
+ : srcloc '|' quals '->' exp { GRHS (reverse (ResultStmt $5 $1:$3)) $1}
-----------------------------------------------------------------------------
-- Statement sequences
stmtlist :: { [RdrNameStmt] }
- : '{' stmts '}' { reverse $2 }
- | layout_on_for_do stmts close { reverse $2 }
-
--- Stmt list should really end in an expression, but it's not
--- convenient to enforce this here, so we throw out erroneous
--- statement sequences in the renamer instead.
-
+ : '{' stmts '}' { $2 }
+ | layout_on_for_do stmts close { $2 }
+
+-- do { ;; s ; s ; ; s ;; }
+-- The last Stmt should be a ResultStmt, but that's hard to enforce
+-- here, because we need too much lookahead if we see do { e ; }
+-- So we use ExprStmts throughout, and switch the last one over
+-- in ParseUtils.checkDo instead
stmts :: { [RdrNameStmt] }
- : ';' stmts1 { $2 }
- | stmts1 { $1 }
+ : stmt stmts_help { $1 : $2 }
+ | ';' stmts { $2 }
+ | {- empty -} { [] }
+
+stmts_help :: { [RdrNameStmt] }
+ : ';' stmts { $2 }
+ | {- empty -} { [] }
-stmts1 :: { [RdrNameStmt] }
- : stmts1 ';' stmt { $3 : $1 }
- | stmts1 ';' { $1 }
- | stmt { [$1] }
+-- For typing stmts at the GHCi prompt, where
+-- the input may consist of just comments.
+maybe_stmt :: { Maybe RdrNameStmt }
+ : stmt { Just $1 }
+ | {- nothing -} { Nothing }
stmt :: { RdrNameStmt }
- : srcloc infixexp '<-' exp {% checkPattern $2 `thenP` \p ->
+ : srcloc infixexp '<-' exp {% checkPattern $1 $2 `thenP` \p ->
returnP (BindStmt p $4 $1) }
| srcloc exp { ExprStmt $2 $1 }
| srcloc 'let' declbinds { LetStmt $3 }
depreclist :: { [RdrName] }
depreclist : deprec_var { [$1] }
- | deprec_var ',' depreclist { $1 : $2 }
+ | deprec_var ',' depreclist { $1 : $3 }
deprec_var :: { RdrName }
deprec_var : var { $1 }
-- *after* we see the close paren.
ipvar :: { RdrName }
- : IPVARID { (mkUnqual ipName (tailFS $1)) }
+ : IPVARID { (mkUnqual varName (tailFS $1)) }
qcon :: { RdrName }
: qconid { $1 }
-- Miscellaneous (mostly renamings)
modid :: { ModuleName }
- : CONID { mkSrcModuleFS $1 }
+ : CONID { mkModuleNameFS $1 }
tycon :: { RdrName }
: CONID { mkUnqual tcClsName $1 }
projects / ghc-hetmet.git / blobdiff