X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fparser%2FParser.y.pp;h=f349f30770e1d40b71542645e19c9f8638cf1aaa;hb=b88025eabcd83f65d1d81f09272f5172f06a60e7;hp=c0d3f4eb9372ba2217110f0bef639475ab56eb40;hpb=1b1e5a46082b74cb7ce05c14def21416375a9545;p=ghc-hetmet.git diff --git a/compiler/parser/Parser.y.pp b/compiler/parser/Parser.y.pp index c0d3f4e..f349f30 100644 --- a/compiler/parser/Parser.y.pp +++ b/compiler/parser/Parser.y.pp @@ -52,6 +52,17 @@ import Control.Monad ( mplus ) {- ----------------------------------------------------------------------------- +6 December 2006 + +Conflicts: 32 shift/reduce + 1 reduce/reduce + +The reduce/reduce conflict is weird. It's between tyconsym and consym, and I +would think the two should never occur in the same context. + + -=chak + +----------------------------------------------------------------------------- 26 July 2006 Conflicts: 37 shift/reduce @@ -491,9 +502,10 @@ topdecls :: { OrdList (LHsDecl RdrName) } topdecl :: { OrdList (LHsDecl RdrName) } : cl_decl { unitOL (L1 (TyClD (unLoc $1))) } | ty_decl { unitOL (L1 (TyClD (unLoc $1))) } - | 'instance' inst_type where - { let (binds, sigs, ats, _) = cvBindsAndSigs (unLoc $3) - in unitOL (L (comb3 $1 $2 $3) (InstD (InstDecl $2 binds sigs ats))) } + | 'instance' inst_type where_inst + { let (binds, sigs, ats, _) = cvBindsAndSigs (unLoc $3) + in + unitOL (L (comb3 $1 $2 $3) (InstD (InstDecl $2 binds sigs ats)))} | stand_alone_deriving { unitOL (LL (DerivD (unLoc $1))) } | 'default' '(' comma_types0 ')' { unitOL (LL $ DefD (DefaultDecl $3)) } | 'foreign' fdecl { unitOL (LL (unLoc $2)) } @@ -510,7 +522,7 @@ topdecl :: { OrdList (LHsDecl RdrName) } -- Type classes -- cl_decl :: { LTyClDecl RdrName } - : 'class' tycl_hdr fds where + : 'class' tycl_hdr fds where_cls {% do { let { (binds, sigs, ats, docs) = cvBindsAndSigs (unLoc $4) ; (ctxt, tc, tvs, tparms) = unLoc $2} @@ -616,9 +628,16 @@ ty_decl :: { LTyClDecl RdrName } (mkTyData (unLoc $1) (ctxt, tc, tvs, Just tparms) (unLoc $4) (reverse (unLoc $6)) (unLoc $7)) } } --- Associate type declarations +-- Associate type family declarations -- -at_decl :: { LTyClDecl RdrName } +-- * They have a different syntax than on the toplevel (no family special +-- identifier). +-- +-- * They also need to be separate from instances; otherwise, data family +-- declarations without a kind signature cause parsing conflicts with empty +-- data declarations. +-- +at_decl_cls :: { LTyClDecl RdrName } -- type family declarations : 'type' type opt_kind_sig -- Note the use of type for the head; this allows @@ -632,7 +651,7 @@ at_decl :: { LTyClDecl RdrName } (TyFunction tc tvs False kind)) } } - -- type instance declarations + -- default type instance | 'type' type '=' ctype -- Note the use of type for the head; this allows -- infix type constructors and type patterns @@ -642,14 +661,30 @@ at_decl :: { LTyClDecl RdrName } (TySynonym tc tvs (Just typats) $4)) } } - -- data/newtype family - | data_or_newtype tycl_hdr '::' kind + -- data/newtype family declaration + | data_or_newtype tycl_hdr opt_kind_sig {% do { let {(ctxt, tc, tvs, tparms) = unLoc $2} ; checkTyVars tparms -- no type pattern + ; let kind = case unLoc $3 of + Nothing -> liftedTypeKind + Just ki -> ki ; return $ - L (comb3 $1 $2 $4) + L (comb3 $1 $2 $3) (mkTyData (unLoc $1) (ctxt, tc, tvs, Nothing) - (Just (unLoc $4)) [] Nothing) } } + (Just kind) [] Nothing) } } + +-- Associate type instances +-- +at_decl_inst :: { LTyClDecl RdrName } + -- type instance declarations + : 'type' type '=' ctype + -- Note the use of type for the head; this allows + -- infix type constructors and type patterns + -- + {% do { (tc, tvs, typats) <- checkSynHdr $2 True + ; return (L (comb2 $1 $4) + (TySynonym tc tvs (Just typats) $4)) + } } -- data/newtype instance declaration | data_or_newtype tycl_hdr constrs deriving @@ -712,32 +747,59 @@ stand_alone_deriving :: { LDerivDecl RdrName } ----------------------------------------------------------------------------- -- Nested declarations --- Type declaration or value declaration +-- Declaration in class bodies -- -tydecl :: { Located (OrdList (LHsDecl RdrName)) } -tydecl : at_decl { LL (unitOL (L1 (TyClD (unLoc $1)))) } - | decl { $1 } - -tydecls :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed - : tydecls ';' tydecl { LL (unLoc $1 `appOL` unLoc $3) } - | tydecls ';' { LL (unLoc $1) } - | tydecl { $1 } - | {- empty -} { noLoc nilOL } +decl_cls :: { Located (OrdList (LHsDecl RdrName)) } +decl_cls : at_decl_cls { LL (unitOL (L1 (TyClD (unLoc $1)))) } + | decl { $1 } + +decls_cls :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed + : decls_cls ';' decl_cls { LL (unLoc $1 `appOL` unLoc $3) } + | decls_cls ';' { LL (unLoc $1) } + | decl_cls { $1 } + | {- empty -} { noLoc nilOL } + + +decllist_cls + :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed + : '{' decls_cls '}' { LL (unLoc $2) } + | vocurly decls_cls close { $2 } +-- Class body +-- +where_cls :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed + -- No implicit parameters + -- May have type declarations + : 'where' decllist_cls { LL (unLoc $2) } + | {- empty -} { noLoc nilOL } + +-- Declarations in instance bodies +-- +decl_inst :: { Located (OrdList (LHsDecl RdrName)) } +decl_inst : at_decl_inst { LL (unitOL (L1 (TyClD (unLoc $1)))) } + | decl { $1 } + +decls_inst :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed + : decls_inst ';' decl_inst { LL (unLoc $1 `appOL` unLoc $3) } + | decls_inst ';' { LL (unLoc $1) } + | decl_inst { $1 } + | {- empty -} { noLoc nilOL } -tydecllist +decllist_inst :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed - : '{' tydecls '}' { LL (unLoc $2) } - | vocurly tydecls close { $2 } + : '{' decls_inst '}' { LL (unLoc $2) } + | vocurly decls_inst close { $2 } --- Form of the body of class and instance declarations +-- Instance body -- -where :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed +where_inst :: { Located (OrdList (LHsDecl RdrName)) } -- Reversed -- No implicit parameters -- May have type declarations - : 'where' tydecllist { LL (unLoc $2) } + : 'where' decllist_inst { LL (unLoc $2) } | {- empty -} { noLoc nilOL } +-- Declarations in binding groups other than classes and instances +-- decls :: { Located (OrdList (LHsDecl RdrName)) } : decls ';' decl { LL (unLoc $1 `appOL` unLoc $3) } | decls ';' { LL (unLoc $1) } @@ -1128,7 +1190,7 @@ docdecld :: { LDocDecl RdrName } decl :: { Located (OrdList (LHsDecl RdrName)) } : sigdecl { $1 } - | '!' infixexp rhs {% do { pat <- checkPattern $2; + | '!' aexp rhs {% do { pat <- checkPattern $2; return (LL $ unitOL $ LL $ ValD ( PatBind (LL $ BangPat pat) (unLoc $3) placeHolderType placeHolderNames)) } } @@ -1183,11 +1245,10 @@ infixexp :: { LHsExpr RdrName } | infixexp qop exp10 { LL (OpApp $1 $2 (panic "fixity") $3) } exp10 :: { LHsExpr RdrName } - : '\\' aexp aexps opt_asig '->' exp - {% checkPatterns ($2 : reverse $3) >>= \ ps -> - return (LL $ HsLam (mkMatchGroup [LL $ Match ps $4 - (unguardedGRHSs $6) - ])) } + : '\\' apat apats opt_asig '->' exp + { LL $ HsLam (mkMatchGroup [LL $ Match ($2:$3) $4 + (unguardedGRHSs $6) + ]) } | 'let' binds 'in' exp { LL $ HsLet (unLoc $2) $4 } | 'if' exp 'then' exp 'else' exp { LL $ HsIf $2 $4 $6 } | 'case' exp 'of' altslist { LL $ HsCase $2 (mkMatchGroup (unLoc $4)) } @@ -1221,14 +1282,9 @@ fexp :: { LHsExpr RdrName } : fexp aexp { LL $ HsApp $1 $2 } | aexp { $1 } -aexps :: { [LHsExpr RdrName] } - : aexps aexp { $2 : $1 } - | {- empty -} { [] } - aexp :: { LHsExpr RdrName } : qvar '@' aexp { LL $ EAsPat $1 $3 } | '~' aexp { LL $ ELazyPat $2 } --- | '!' aexp { LL $ EBangPat $2 } | aexp1 { $1 } aexp1 :: { LHsExpr RdrName } @@ -1381,10 +1437,7 @@ alts1 :: { Located [LMatch RdrName] } | alt { L1 [$1] } alt :: { LMatch RdrName } - : infixexp opt_sig alt_rhs {% checkPattern $1 >>= \p -> - return (LL (Match [p] $2 (unLoc $3))) } - | '!' infixexp opt_sig alt_rhs {% checkPattern $2 >>= \p -> - return (LL (Match [LL $ BangPat p] $3 (unLoc $4))) } + : pat opt_sig alt_rhs { LL (Match [$1] $2 (unLoc $3)) } alt_rhs :: { Located (GRHSs RdrName) } : ralt wherebinds { LL (GRHSs (unLoc $1) (unLoc $2)) } @@ -1400,6 +1453,22 @@ gdpats :: { Located [LGRHS RdrName] } gdpat :: { LGRHS RdrName } : '|' quals '->' exp { sL (comb2 $1 $>) $ GRHS (reverse (unLoc $2)) $4 } +-- 'pat' recognises a pattern, including one with a bang at the top +-- e.g. "!x" or "!(x,y)" or "C a b" etc +-- Bangs inside are parsed as infix operator applications, so that +-- we parse them right when bang-patterns are off +pat :: { LPat RdrName } +pat : infixexp {% checkPattern $1 } + | '!' aexp {% checkPattern (LL (SectionR (L1 (HsVar bang_RDR)) $2)) } + +apat :: { LPat RdrName } +apat : aexp {% checkPattern $1 } + | '!' aexp {% checkPattern (LL (SectionR (L1 (HsVar bang_RDR)) $2)) } + +apats :: { [LPat RdrName] } + : apat apats { $1 : $2 } + | {- empty -} { [] } + ----------------------------------------------------------------------------- -- Statement sequences @@ -1429,13 +1498,13 @@ maybe_stmt :: { Maybe (LStmt RdrName) } stmt :: { LStmt RdrName } : qual { $1 } +-- What is this next production doing? I have no clue! SLPJ Dec06 | infixexp '->' exp {% checkPattern $3 >>= \p -> return (LL $ mkBindStmt p $1) } | 'rec' stmtlist { LL $ mkRecStmt (unLoc $2) } qual :: { LStmt RdrName } - : exp '<-' exp {% checkPattern $1 >>= \p -> - return (LL $ mkBindStmt p $3) } + : pat '<-' exp { LL $ mkBindStmt $1 $3 } | exp { L1 $ mkExprStmt $1 } | 'let' binds { LL $ LetStmt (unLoc $2) } @@ -1755,7 +1824,7 @@ moduleheader :: { (HaddockModInfo RdrName, Maybe (HsDoc RdrName)) } Left err -> parseError (getLoc $1) err; Right doc -> return (info, Just doc); }; - Left err -> parseError (getLoc $1) err + Left err -> parseError (getLoc $1) err } } maybe_docprev :: { Maybe (LHsDoc RdrName) }