X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fparser%2FParser.y;h=d067c645106d5dc47ba01027b988b8df79241c75;hb=6eca2acf184d4911123193757bdd38e53caa3467;hp=44dd9e9e830307ac2f04b3adf994581f83e07df3;hpb=324ec54384803cd54035677ce8b2569734c4f238;p=ghc-hetmet.git diff --git a/ghc/compiler/parser/Parser.y b/ghc/compiler/parser/Parser.y index 44dd9e9..d067c64 100644 --- a/ghc/compiler/parser/Parser.y +++ b/ghc/compiler/parser/Parser.y @@ -1,6 +1,6 @@ {- ----------------------------------------------------------------------------- -$Id: Parser.y,v 1.16 1999/11/25 10:34:53 simonpj Exp $ +$Id: Parser.y,v 1.41 2000/10/12 11:47:26 sewardj Exp $ Haskell grammar. @@ -13,21 +13,25 @@ module Parser ( parse ) where import HsSyn import HsPragmas +import HsTypes ( mkHsTupCon ) +import HsPat ( InPat(..) ) import RdrHsSyn import Lex import ParseUtil import RdrName -import PrelMods ( mAIN_Name ) -import OccName ( varName, dataName, tcClsName, tvName ) +import PrelInfo ( mAIN_Name ) +import OccName ( UserFS, varName, ipName, tcName, dataName, tcClsName, tvName ) import SrcLoc ( SrcLoc ) import Module import CallConv import CmdLineOpts ( opt_SccProfilingOn ) -import BasicTypes ( Fixity(..), FixityDirection(..), NewOrData(..) ) +import BasicTypes ( Boxity(..), Fixity(..), FixityDirection(..), NewOrData(..) ) import Panic import GlaExts +import FastString ( tailFS ) +import Outputable #include "HsVersions.h" } @@ -35,6 +39,7 @@ import GlaExts {- ----------------------------------------------------------------------------- Conflicts: 14 shift/reduce + (note: it's currently 21 -- JRL, 31/1/2000) 8 for abiguity in 'if x then y else z + 1' (shift parses as 'if x then y else (z + 1)', as per longest-parse rule) @@ -93,6 +98,7 @@ Conflicts: 14 shift/reduce 'label' { ITlabel } 'dynamic' { ITdynamic } 'unsafe' { ITunsafe } + 'with' { ITwith } 'stdcall' { ITstdcallconv } 'ccall' { ITccallconv } '_ccall_' { ITccall (False, False, False) } @@ -105,6 +111,7 @@ Conflicts: 14 shift/reduce '{-# INLINE' { ITinline_prag } '{-# NOINLINE' { ITnoinline_prag } '{-# RULES' { ITrules_prag } + '{-# DEPRECATED' { ITdeprecated_prag } '#-}' { ITclose_prag } {- @@ -122,6 +129,7 @@ Conflicts: 14 shift/reduce '__float' { ITfloat_lit } '__rational' { ITrational_lit } '__addr' { ITaddr_lit } + '__label' { ITlabel_lit } '__litlit' { ITlit_lit } '__string' { ITstring_lit } '__ccall' { ITccall $$ } @@ -150,10 +158,10 @@ Conflicts: 14 shift/reduce '!' { ITbang } '.' { ITdot } - '/\\' { ITbiglam } -- GHC-extension symbols - '{' { ITocurly } -- special symbols '}' { ITccurly } + '{|' { ITocurlybar } + '|}' { ITccurlybar } vccurly { ITvccurly } -- virtual close curly (from layout) '[' { ITobrack } ']' { ITcbrack } @@ -174,7 +182,7 @@ Conflicts: 14 shift/reduce QVARSYM { ITqvarsym $$ } QCONSYM { ITqconsym $$ } - PRAGMA { ITpragma $$ } + IPVARID { ITipvarid $$ } -- GHC extension CHAR { ITchar $$ } STRING { ITstring $$ } @@ -185,11 +193,9 @@ Conflicts: 14 shift/reduce PRIMSTRING { ITprimstring $$ } PRIMINTEGER { ITprimint $$ } PRIMFLOAT { ITprimfloat $$ } - PRIMDOUBLE { ITprimdouble $$ } + PRIMDOUBLE { ITprimdouble $$ } CLITLIT { ITlitlit $$ } - UNKNOWN { ITunknown $$ } - %monad { P } { thenP } { returnP } %lexer { lexer } { ITeof } %name parse @@ -199,19 +205,30 @@ Conflicts: 14 shift/reduce ----------------------------------------------------------------------------- -- Module Header +-- The place for module deprecation is really too restrictive, but if it +-- was allowed at its natural place just before 'module', we get an ugly +-- s/r conflict with the second alternative. Another solution would be the +-- introduction of a new pragma DEPRECATED_MODULE, but this is not very nice, +-- either, and DEPRECATED is only expected to be used by people who really +-- know what they are doing. :-) + module :: { RdrNameHsModule } - : srcloc 'module' modid maybeexports 'where' body - { HsModule $3 Nothing $4 (fst $6) (snd $6) $1 } - | srcloc body - { HsModule mAIN_Name Nothing Nothing (fst $2) (snd $2) $1 } + : srcloc 'module' modid maybemoddeprec maybeexports 'where' body + { HsModule $3 Nothing $5 (fst $7) (snd $7) $4 $1 } + | srcloc body + { HsModule mAIN_Name Nothing Nothing (fst $2) (snd $2) Nothing $1 } + +maybemoddeprec :: { Maybe DeprecTxt } + : '{-# DEPRECATED' STRING '#-}' { Just $2 } + | {- empty -} { Nothing } body :: { ([RdrNameImportDecl], [RdrNameHsDecl]) } : '{' top '}' { $2 } | layout_on top close { $2 } top :: { ([RdrNameImportDecl], [RdrNameHsDecl]) } - : importdecls ';' cvtopdecls { (reverse $1,$3) } - | importdecls { (reverse $1,[]) } + : importdecls { (reverse $1,[]) } + | importdecls ';' cvtopdecls { (reverse $1,$3) } | cvtopdecls { ([],$1) } cvtopdecls :: { [RdrNameHsDecl] } @@ -309,37 +326,35 @@ topdecls :: { [RdrBinding] } | topdecl { [$1] } topdecl :: { RdrBinding } - : srcloc 'type' simpletype '=' type + : srcloc 'type' simpletype '=' sigtype { RdrHsDecl (TyClD (TySynonym (fst $3) (snd $3) $5 $1)) } | srcloc 'data' ctype '=' constrs deriving {% checkDataHeader $3 `thenP` \(cs,c,ts) -> returnP (RdrHsDecl (TyClD - (TyData DataType cs c ts (reverse $5) $6 + (mkTyData DataType cs c ts (reverse $5) (length $5) $6 NoDataPragmas $1))) } | srcloc 'newtype' ctype '=' newconstr deriving {% checkDataHeader $3 `thenP` \(cs,c,ts) -> returnP (RdrHsDecl (TyClD - (TyData NewType cs c ts [$5] $6 + (mkTyData NewType cs c ts [$5] 1 $6 NoDataPragmas $1))) } - | srcloc 'class' ctype where + | srcloc 'class' ctype fds where {% checkDataHeader $3 `thenP` \(cs,c,ts) -> - let (binds,sigs) - = cvMonoBindsAndSigs cvClassOpSig - (groupBindings $4) + let + (binds,sigs) = cvMonoBindsAndSigs cvClassOpSig (groupBindings $5) in returnP (RdrHsDecl (TyClD - (mkClassDecl cs c ts sigs binds + (mkClassDecl cs c ts $4 sigs binds NoClassPragmas $1))) } | srcloc 'instance' inst_type where { let (binds,sigs) = cvMonoBindsAndSigs cvInstDeclSig (groupBindings $4) - in RdrHsDecl (InstD - (InstDecl $3 binds sigs dummyRdrVarName $1)) } + in RdrHsDecl (InstD (InstDecl $3 binds sigs Nothing $1)) } | srcloc 'default' '(' types0 ')' { RdrHsDecl (DefD (DefaultDecl $4 $1)) } @@ -355,7 +370,9 @@ topdecl :: { RdrBinding } { RdrHsDecl (ForD (ForeignDecl $5 FoLabel $7 (mkExtName $4 $5) defaultCallConv $1)) } - | decl { $1 } + | '{-# DEPRECATED' deprecations '#-}' { $2 } + | '{-# RULES' rules '#-}' { $2 } + | decl { $1 } decls :: { [RdrBinding] } : decls ';' decl { $3 : $1 } @@ -364,9 +381,8 @@ decls :: { [RdrBinding] } | {- empty -} { [] } decl :: { RdrBinding } - : signdecl { $1 } - | fixdecl { $1 } - | valdef { RdrValBinding $1 } + : fixdecl { $1 } + | valdef { $1 } | '{-# INLINE' srcloc opt_phase qvar '#-}' { RdrSig (InlineSig $4 $3 $2) } | '{-# NOINLINE' srcloc opt_phase qvar '#-}' { RdrSig (NoInlineSig $4 $3 $2) } | '{-# SPECIALISE' srcloc qvar '::' sigtypes '#-}' @@ -374,16 +390,11 @@ decl :: { RdrBinding } (map (\t -> RdrSig (SpecSig $3 t $2)) $5) } | '{-# SPECIALISE' srcloc 'instance' inst_type '#-}' { RdrSig (SpecInstSig $4 $2) } - | '{-# RULES' rules '#-}' { $2 } opt_phase :: { Maybe Int } : INTEGER { Just (fromInteger $1) } | {- empty -} { Nothing } -sigtypes :: { [RdrNameHsType] } - : sigtype { [ $1 ] } - | sigtypes ',' sigtype { $3 : $1 } - wherebinds :: { RdrNameHsBinds } : where { cvBinds cvValSig (groupBindings $1) } @@ -404,30 +415,6 @@ fixdecl :: { RdrBinding } (Fixity $3 $2) $1)) | n <- $4 ] } -signdecl :: { RdrBinding } - : vars srcloc '::' sigtype { foldr1 RdrAndBindings - [ RdrSig (Sig n $4 $2) | n <- $1 ] } - -sigtype :: { RdrNameHsType } - : ctype { mkHsForAllTy Nothing [] $1 } - -{- - ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var - instead of qvar, we get another shift/reduce-conflict. Consider the - following programs: - - { (+) :: ... } only var - { (+) x y = ... } could (incorrectly) be qvar - - We re-use expressions for patterns, so a qvar would be allowed in patterns - instead of a var only (which would be correct). But deciding what the + is, - would require more lookahead. So let's check for ourselves... --} - -vars :: { [RdrName] } - : vars ',' var { $3 : $1 } - | qvar { [ $1 ] } - ----------------------------------------------------------------------------- -- Transformation Rules @@ -439,7 +426,7 @@ rules :: { RdrBinding } rule :: { RdrBinding } : STRING rule_forall fexp '=' srcloc exp - { RdrHsDecl (RuleD (RuleDecl $1 [] $2 $3 $6 $5)) } + { RdrHsDecl (RuleD (HsRule $1 [] $2 $3 $6 $5)) } rule_forall :: { [RdrNameRuleBndr] } : 'forall' rule_var_list '.' { $2 } @@ -454,6 +441,21 @@ rule_var :: { RdrNameRuleBndr } | '(' varid '::' ctype ')' { RuleBndrSig $2 $4 } ----------------------------------------------------------------------------- +-- Deprecations + +deprecations :: { RdrBinding } + : deprecations ';' deprecation { $1 `RdrAndBindings` $3 } + | deprecations ';' { $1 } + | deprecation { $1 } + | {- empty -} { RdrNullBind } + +-- SUP: TEMPORARY HACK, not checking for `module Foo' +deprecation :: { RdrBinding } + : srcloc exportlist STRING + { foldr RdrAndBindings RdrNullBind + [ RdrHsDecl (DeprecD (Deprecation n $3 $1)) | n <- $2 ] } + +----------------------------------------------------------------------------- -- Foreign import/export callconv :: { Int } @@ -471,6 +473,29 @@ ext_name :: { Maybe ExtName } | STRING STRING { Just (ExtName $2 (Just $1)) } | {- empty -} { Nothing } + +----------------------------------------------------------------------------- +-- Type signatures + +opt_sig :: { Maybe RdrNameHsType } + : {- empty -} { Nothing } + | '::' sigtype { Just $2 } + +opt_asig :: { Maybe RdrNameHsType } + : {- empty -} { Nothing } + | '::' atype { Just $2 } + +sigtypes :: { [RdrNameHsType] } + : sigtype { [ $1 ] } + | sigtypes ',' sigtype { $3 : $1 } + +sigtype :: { RdrNameHsType } + : ctype { (mkHsForAllTy Nothing [] $1) } + +sig_vars :: { [RdrName] } + : sig_vars ',' var { $3 : $1 } + | var { [ $1 ] } + ----------------------------------------------------------------------------- -- Types @@ -478,31 +503,32 @@ ext_name :: { Maybe ExtName } ctype :: { RdrNameHsType } : 'forall' tyvars '.' ctype { mkHsForAllTy (Just $2) [] $4 } | context type { mkHsForAllTy Nothing $1 $2 } - -- A type of form (context => type) is an *implicit* HsForAllTy + -- A type of form (context => type) is an *implicit* HsForAllTy | type { $1 } type :: { RdrNameHsType } - : btype '->' type { MonoFunTy $1 $3 } - | btype { $1 } + : gentype '->' type { HsFunTy $1 $3 } + | ipvar '::' type { mkHsIParamTy $1 $3 } + | gentype { $1 } + +gentype :: { RdrNameHsType } + : btype { $1 } +-- Generics + | atype tyconop atype { HsOpTy $1 $2 $3 } btype :: { RdrNameHsType } - : btype atype { MonoTyApp $1 $2 } + : btype atype { (HsAppTy $1 $2) } | atype { $1 } atype :: { RdrNameHsType } - : gtycon { MonoTyVar $1 } - | tyvar { MonoTyVar $1 } - | '(' type ',' types ')' { MonoTupleTy ($2 : reverse $4) True } - | '(#' types '#)' { MonoTupleTy (reverse $2) False } - | '[' type ']' { MonoListTy $2 } - | '(' ctype ')' { $2 } - -gtycon :: { RdrName } - : qtycon { $1 } - | '(' ')' { unitTyCon_RDR } - | '(' '->' ')' { funTyCon_RDR } - | '[' ']' { listTyCon_RDR } - | '(' commas ')' { tupleTyCon_RDR $2 } + : gtycon { HsTyVar $1 } + | tyvar { HsTyVar $1 } + | '(' type ',' types ')' { HsTupleTy (mkHsTupCon tcName Boxed ($2:$4)) ($2 : reverse $4) } + | '(#' types '#)' { HsTupleTy (mkHsTupCon tcName Unboxed $2) (reverse $2) } + | '[' type ']' { HsListTy $2 } + | '(' ctype ')' { $2 } +-- Generics + | INTEGER { HsNumTy $1 } -- An inst_type is what occurs in the head of an instance decl -- e.g. (Foo a, Gaz b) => Wibble a b @@ -526,18 +552,38 @@ tyvars :: { [RdrNameHsTyVar] } : tyvars tyvar { UserTyVar $2 : $1 } | {- empty -} { [] } +fds :: { [([RdrName], [RdrName])] } + : {- empty -} { [] } + | '|' fds1 { reverse $2 } + +fds1 :: { [([RdrName], [RdrName])] } + : fds1 ',' fd { $3 : $1 } + | fd { [$1] } + +fd :: { ([RdrName], [RdrName]) } + : varids0 '->' varids0 { (reverse $1, reverse $3) } + +varids0 :: { [RdrName] } + : {- empty -} { [] } + | varids0 tyvar { $2 : $1 } + ----------------------------------------------------------------------------- -- Datatype declarations +newconstr :: { RdrNameConDecl } + : srcloc conid atype { mkConDecl $2 [] [] (VanillaCon [Unbanged $3]) $1 } + | srcloc conid '{' var '::' type '}' + { mkConDecl $2 [] [] (RecCon [([$4], Unbanged $6)]) $1 } + constrs :: { [RdrNameConDecl] } : constrs '|' constr { $3 : $1 } | constr { [$1] } constr :: { RdrNameConDecl } : srcloc forall context constr_stuff - { ConDecl (fst $4) $2 $3 (snd $4) $1 } + { mkConDecl (fst $4) $2 $3 (snd $4) $1 } | srcloc forall constr_stuff - { ConDecl (fst $3) $2 [] (snd $3) $1 } + { mkConDecl (fst $3) $2 [] (snd $3) $1 } forall :: { [RdrNameHsTyVar] } : 'forall' tyvars '.' { $2 } @@ -547,37 +593,26 @@ context :: { RdrNameContext } : btype '=>' {% checkContext $1 } constr_stuff :: { (RdrName, RdrNameConDetails) } - : scontype { (fst $1, VanillaCon (snd $1)) } + : btype {% mkVanillaCon $1 [] } + | btype '!' atype satypes {% mkVanillaCon $1 (Banged $3 : $4) } + | gtycon '{' fielddecls '}' {% mkRecCon $1 $3 } | sbtype conop sbtype { ($2, InfixCon $1 $3) } - | con '{' fielddecls '}' { ($1, RecCon (reverse $3)) } - -newconstr :: { RdrNameConDecl } - : srcloc conid atype { ConDecl $2 [] [] (NewCon $3 Nothing) $1 } - | srcloc conid '{' var '::' type '}' - { ConDecl $2 [] [] (NewCon $6 (Just $4)) $1 } - -scontype :: { (RdrName, [RdrNameBangType]) } - : btype {% splitForConApp $1 [] } - | scontype1 { $1 } -scontype1 :: { (RdrName, [RdrNameBangType]) } - : btype '!' atype {% splitForConApp $1 [Banged $3] } - | scontype1 satype { (fst $1, snd $1 ++ [$2] ) } - -satype :: { RdrNameBangType } - : atype { Unbanged $1 } - | '!' atype { Banged $2 } +satypes :: { [RdrNameBangType] } + : atype satypes { Unbanged $1 : $2 } + | '!' atype satypes { Banged $2 : $3 } + | {- empty -} { [] } sbtype :: { RdrNameBangType } : btype { Unbanged $1 } | '!' atype { Banged $2 } fielddecls :: { [([RdrName],RdrNameBangType)] } - : fielddecls ',' fielddecl { $3 : $1 } + : fielddecl ',' fielddecls { $1 : $3 } | fielddecl { [$1] } fielddecl :: { ([RdrName],RdrNameBangType) } - : vars '::' stype { (reverse $1, $3) } + : sig_vars '::' stype { (reverse $1, $3) } stype :: { RdrNameBangType } : ctype { Unbanged $1 } @@ -596,13 +631,37 @@ dclasses :: { [RdrName] } ----------------------------------------------------------------------------- -- Value definitions -valdef :: { RdrNameMonoBinds } - : infixexp {-ToDo: opt_sig-} srcloc rhs - {% checkValDef $1 Nothing $3 $2 } +{- There's an awkward overlap with a type signature. Consider + f :: Int -> Int = ...rhs... + Then we can't tell whether it's a type signature or a value + definition with a result signature until we see the '='. + So we have to inline enough to postpone reductions until we know. +-} + +{- + ATTENTION: Dirty Hackery Ahead! If the second alternative of vars is var + instead of qvar, we get another shift/reduce-conflict. Consider the + following programs: + + { (^^) :: Int->Int ; } Type signature; only var allowed + + { (^^) :: Int->Int = ... ; } Value defn with result signature; + qvar allowed (because of instance decls) + + We can't tell whether to reduce var to qvar until after we've read the signatures. +-} + +valdef :: { RdrBinding } + : infixexp srcloc opt_sig rhs {% (checkValDef $1 $3 $4 $2) } + | infixexp srcloc '::' sigtype {% (checkValSig $1 $4 $2) } + | var ',' sig_vars srcloc '::' sigtype { foldr1 RdrAndBindings + [ RdrSig (Sig n $6 $4) | n <- $1:$3 ] + } + rhs :: { RdrNameGRHSs } - : '=' srcloc exp wherebinds { GRHSs (unguardedRHS $3 $2) - $4 Nothing} + : '=' srcloc exp wherebinds { (GRHSs (unguardedRHS $3 $2) + $4 Nothing)} | gdrhs wherebinds { GRHSs (reverse $1) $2 Nothing } gdrhs :: { [RdrNameGRHS] } @@ -610,19 +669,20 @@ gdrhs :: { [RdrNameGRHS] } | gdrh { [$1] } gdrh :: { RdrNameGRHS } - : '|' srcloc quals '=' exp { GRHS (reverse - (ExprStmt $5 $2 : $3)) $2 } + : '|' srcloc quals '=' exp { GRHS (reverse (ExprStmt $5 $2 : $3)) $2 } ----------------------------------------------------------------------------- -- Expressions exp :: { RdrNameHsExpr } - : infixexp '::' sigtype { ExprWithTySig $1 $3 } + : infixexp '::' sigtype { (ExprWithTySig $1 $3) } + | infixexp 'with' dbinding { HsWith $1 $3 } | infixexp { $1 } infixexp :: { RdrNameHsExpr } : exp10 { $1 } - | infixexp qop exp10 { OpApp $1 $2 (panic "fixity") $3 } + | infixexp qop exp10 { (OpApp $1 (HsVar $2) + (panic "fixity") $3 )} exp10 :: { RdrNameHsExpr } : '\\' aexp aexps opt_asig '->' srcloc exp @@ -633,13 +693,13 @@ exp10 :: { RdrNameHsExpr } | '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 { NegApp $2 (error "NegApp") } + | '-' fexp { mkHsNegApp $2 } | srcloc 'do' stmtlist { HsDo DoStmt $3 $1 } - | '_ccall_' ccallid aexps0 { CCall $2 $3 False False cbot } - | '_ccall_GC_' ccallid aexps0 { CCall $2 $3 True False cbot } - | '_casm_' CLITLIT aexps0 { CCall $2 $3 False True cbot } - | '_casm_GC_' CLITLIT aexps0 { CCall $2 $3 True True cbot } + | '_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 @@ -652,42 +712,47 @@ ccallid :: { FAST_STRING } | CONID { $1 } fexp :: { RdrNameHsExpr } - : fexp aexp { HsApp $1 $2 } + : fexp aexp { (HsApp $1 $2) } | aexp { $1 } aexps0 :: { [RdrNameHsExpr] } - : aexps { reverse $1 } + : aexps { (reverse $1) } aexps :: { [RdrNameHsExpr] } : aexps aexp { $2 : $1 } | {- empty -} { [] } aexp :: { RdrNameHsExpr } - : aexp '{' fbinds '}' {% mkRecConstrOrUpdate $1 (reverse $3) } - | aexp1 { $1 } + : var_or_con '{|' gentype '|}' { (HsApp $1 (HsType $3)) } + | aexp '{' fbinds '}' {% (mkRecConstrOrUpdate $1 + (reverse $3)) } + | aexp1 { $1 } + +var_or_con :: { RdrNameHsExpr } + : qvar { HsVar $1 } + | gcon { HsVar $1 } aexp1 :: { RdrNameHsExpr } - : qvar { HsVar $1 } - | gcon { HsVar $1 } - | literal { HsLit $1 } + : ipvar { HsIPVar $1 } + | var_or_con { $1 } + | literal { HsLit $1 } + | INTEGER { HsOverLit (mkHsIntegralLit $1) } + | RATIONAL { HsOverLit (mkHsFractionalLit $1) } | '(' exp ')' { HsPar $2 } - | '(' exp ',' texps ')' { ExplicitTuple ($2 : reverse $4) True } - | '(#' texps '#)' { ExplicitTuple (reverse $2) False } + | '(' exp ',' texps ')' { ExplicitTuple ($2 : reverse $4) Boxed} + | '(#' texps '#)' { ExplicitTuple (reverse $2) Unboxed } | '[' list ']' { $2 } - | '(' infixexp qop ')' { SectionL $2 $3 } - | '(' qopm infixexp ')' { SectionR $2 $3 } + | '(' infixexp qop ')' { (SectionL $2 (HsVar $3)) } + | '(' qopm infixexp ')' { (SectionR $2 $3) } | qvar '@' aexp { EAsPat $1 $3 } | '_' { EWildPat } | '~' aexp1 { ELazyPat $2 } -commas :: { Int } - : commas ',' { $1 + 1 } - | ',' { 2 } - texps :: { [RdrNameHsExpr] } : texps ',' exp { $3 : $1 } | exp { [$1] } + ----------------------------------------------------------------------------- -- List expressions @@ -728,26 +793,20 @@ altslist :: { [RdrNameMatch] } : '{' alts '}' { reverse $2 } | layout_on alts close { reverse $2 } +alts :: { [RdrNameMatch] } + : alts1 { $1 } + | ';' alts { $2 } -alts :: { [RdrNameMatch] } - : alts ';' alt { $3 : $1 } - | alts ';' { $1 } +alts1 :: { [RdrNameMatch] } + : alts1 ';' alt { $3 : $1 } + | alts1 ';' { $1 } | alt { [$1] } - | {- empty -} { [] } alt :: { RdrNameMatch } : infixexp opt_sig ralt wherebinds - {% checkPattern $1 `thenP` \p -> + {% (checkPattern $1 `thenP` \p -> returnP (Match [] [p] $2 - (GRHSs $3 $4 Nothing)) } - -opt_sig :: { Maybe RdrNameHsType } - : {- empty -} { Nothing } - | '::' type { Just $2 } - -opt_asig :: { Maybe RdrNameHsType } - : {- empty -} { Nothing } - | '::' atype { Just $2 } + (GRHSs $3 $4 Nothing)) )} ralt :: { [RdrNameGRHS] } : '->' srcloc exp { [GRHS [ExprStmt $3 $2] $2] } @@ -799,8 +858,32 @@ fbind :: { (RdrName, RdrNameHsExpr, Bool) } : qvar '=' exp { ($1,$3,False) } ----------------------------------------------------------------------------- +-- Implicit Parameter Bindings + +dbinding :: { [(RdrName, RdrNameHsExpr)] } + : '{' dbinds '}' { $2 } + | layout_on dbinds close { $2 } + +dbinds :: { [(RdrName, RdrNameHsExpr)] } + : dbinds ';' dbind { $3 : $1 } + | dbinds ';' { $1 } + | dbind { [$1] } + | {- empty -} { [] } + +dbind :: { (RdrName, RdrNameHsExpr) } +dbind : ipvar '=' exp { ($1, $3) } + +----------------------------------------------------------------------------- -- Variables, Constructors and Operators. +gtycon :: { RdrName } + : qtycon { $1 } + | '(' qtyconop ')' { $2 } + | '(' ')' { unitTyCon_RDR } + | '(' '->' ')' { funTyCon_RDR } + | '[' ']' { listTyCon_RDR } + | '(' commas ')' { tupleTyCon_RDR $2 } + gcon :: { RdrName } : '(' ')' { unitCon_RDR } | '[' ']' { nilCon_RDR } @@ -813,11 +896,14 @@ var :: { RdrName } qvar :: { RdrName } : qvarid { $1 } - | '(' qvarsym ')' { $2 } + | '(' varsym ')' { $2 } + | '(' qvarsym1 ')' { $2 } +-- We've inlined qvarsym here so that the decision about +-- whether it's a qvar or a var can be postponed until +-- *after* we see the close paren. -con :: { RdrName } - : conid { $1 } - | '(' consym ')' { $2 } +ipvar :: { RdrName } + : IPVARID { (mkUnqual ipName (tailFS $1)) } qcon :: { RdrName } : qconid { $1 } @@ -832,7 +918,7 @@ qvarop :: { RdrName } | '`' qvarid '`' { $2 } qvaropm :: { RdrName } - : qvarsymm { $1 } + : qvarsym_no_minus { $1 } | '`' qvarid '`' { $2 } conop :: { RdrName } @@ -850,9 +936,9 @@ op :: { RdrName } -- used in infix decls : varop { $1 } | conop { $1 } -qop :: { RdrNameHsExpr } -- used in sections - : qvarop { HsVar $1 } - | qconop { HsVar $1 } +qop :: { RdrName {-HsExpr-} } -- used in sections + : qvarop { $1 } + | qconop { $1 } qopm :: { RdrNameHsExpr } -- used in sections : qvaropm { HsVar $1 } @@ -863,55 +949,55 @@ qopm :: { RdrNameHsExpr } -- used in sections qvarid :: { RdrName } : varid { $1 } - | QVARID { case $1 of { (mod,n) -> - mkSrcQual varName mod n } } + | QVARID { mkQual varName $1 } varid :: { RdrName } - : VARID { mkSrcUnqual varName $1 } - | 'as' { as_var_RDR } - | 'qualified' { qualified_var_RDR } - | 'hiding' { hiding_var_RDR } - | 'forall' { forall_var_RDR } - | 'export' { export_var_RDR } - | 'label' { label_var_RDR } - | 'dynamic' { dynamic_var_RDR } - | 'unsafe' { unsafe_var_RDR } - | 'stdcall' { stdcall_var_RDR } - | 'ccall' { ccall_var_RDR } + : varid_no_unsafe { $1 } + | 'unsafe' { mkUnqual varName SLIT("unsafe") } varid_no_unsafe :: { RdrName } - : VARID { mkSrcUnqual varName $1 } - | 'as' { as_var_RDR } - | 'qualified' { qualified_var_RDR } - | 'hiding' { hiding_var_RDR } - | 'forall' { forall_var_RDR } - | 'export' { export_var_RDR } - | 'label' { label_var_RDR } - | 'dynamic' { dynamic_var_RDR } - | 'stdcall' { stdcall_var_RDR } - | 'ccall' { ccall_var_RDR } + : VARID { mkUnqual varName $1 } + | special_id { mkUnqual varName $1 } + | 'forall' { mkUnqual varName SLIT("forall") } + +tyvar :: { RdrName } + : VARID { mkUnqual tvName $1 } + | special_id { mkUnqual tvName $1 } + | 'unsafe' { mkUnqual tvName SLIT("unsafe") } + +-- These special_ids are treated as keywords in various places, +-- but as ordinary ids elsewhere. A special_id collects all thsee +-- 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 } : conid { $1 } - | QCONID { case $1 of { (mod,n) -> - mkSrcQual dataName mod n } } + | QCONID { mkQual dataName $1 } conid :: { RdrName } - : CONID { mkSrcUnqual dataName $1 } + : CONID { mkUnqual dataName $1 } ----------------------------------------------------------------------------- -- ConSyms qconsym :: { RdrName } : consym { $1 } - | QCONSYM { case $1 of { (mod,n) -> - mkSrcQual dataName mod n } } + | QCONSYM { mkQual dataName $1 } consym :: { RdrName } - : CONSYM { mkSrcUnqual dataName $1 } + : CONSYM { mkUnqual dataName $1 } ----------------------------------------------------------------------------- -- VarSyms @@ -920,37 +1006,39 @@ qvarsym :: { RdrName } : varsym { $1 } | qvarsym1 { $1 } -qvarsymm :: { RdrName } - : varsymm { $1 } +qvarsym_no_minus :: { RdrName } + : varsym_no_minus { $1 } | qvarsym1 { $1 } +qvarsym1 :: { RdrName } +qvarsym1 : QVARSYM { mkQual varName $1 } + varsym :: { RdrName } - : VARSYM { mkSrcUnqual varName $1 } - | '-' { minus_RDR } - | '!' { pling_RDR } - | '.' { dot_RDR } + : varsym_no_minus { $1 } + | '-' { mkUnqual varName SLIT("-") } -varsymm :: { RdrName } -- varsym not including '-' - : VARSYM { mkSrcUnqual varName $1 } - | '!' { pling_RDR } - | '.' { dot_RDR } +varsym_no_minus :: { RdrName } -- varsym not including '-' + : VARSYM { mkUnqual varName $1 } + | special_sym { mkUnqual varName $1 } -qvarsym1 :: { RdrName } - : QVARSYM { case $1 of { (mod,n) -> - mkSrcQual varName mod n } } -literal :: { HsLit } - : INTEGER { HsInt $1 } - | CHAR { HsChar $1 } - | RATIONAL { HsFrac $1 } - | STRING { HsString $1 } +-- See comments with special_id +special_sym :: { UserFS } +special_sym : '!' { SLIT("!") } + | '.' { SLIT(".") } + +----------------------------------------------------------------------------- +-- Literals +literal :: { HsLit } + : CHAR { HsChar $1 } + | STRING { HsString $1 } | PRIMINTEGER { HsIntPrim $1 } | PRIMCHAR { HsCharPrim $1 } | PRIMSTRING { HsStringPrim $1 } | PRIMFLOAT { HsFloatPrim $1 } | PRIMDOUBLE { HsDoublePrim $1 } - | CLITLIT { HsLitLit $1 } + | CLITLIT { HsLitLit $1 (error "Parser.y: CLITLIT") } srcloc :: { SrcLoc } : {% getSrcLocP } @@ -971,28 +1059,25 @@ modid :: { ModuleName } : CONID { mkSrcModuleFS $1 } tycon :: { RdrName } - : CONID { mkSrcUnqual tcClsName $1 } + : CONID { mkUnqual tcClsName $1 } + +tyconop :: { RdrName } + : CONSYM { mkUnqual tcClsName $1 } qtycon :: { RdrName } : tycon { $1 } - | QCONID { case $1 of { (mod,n) -> - mkSrcQual tcClsName mod n } } + | QCONID { mkQual tcClsName $1 } + +qtyconop :: { RdrName } + : tyconop { $1 } + | QCONSYM { mkQual tcClsName $1 } qtycls :: { RdrName } : qtycon { $1 } -tyvar :: { RdrName } - : VARID { mkSrcUnqual tvName $1 } - | 'as' { as_tyvar_RDR } - | 'qualified' { qualified_tyvar_RDR } - | 'hiding' { hiding_tyvar_RDR } - | 'export' { export_tyvar_RDR } - | 'label' { label_tyvar_RDR } - | 'dynamic' { dynamic_tyvar_RDR } - | 'unsafe' { unsafe_tyvar_RDR } - | 'stdcall' { stdcall_tyvar_RDR } - | 'ccall' { ccall_tyvar_RDR } - -- NOTE: no 'forall' +commas :: { Int } + : commas ',' { $1 + 1 } + | ',' { 2 } -----------------------------------------------------------------------------