{-
-----------------------------------------------------------------------------
+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
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)) }
-- 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}
(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
(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
(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
-----------------------------------------------------------------------------
-- 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) }
: btype { $1 }
| btype qtyconop gentype { LL $ HsOpTy $1 $2 $3 }
| btype tyvarop gentype { LL $ HsOpTy $1 $2 $3 }
- | btype '->' ctype { LL $ HsFunTy $1 $3 }
+ | btype '->' ctype { LL $ HsFunTy $1 $3 }
+ | btype '~' gentype { LL $ HsPredTy (HsEqualP $1 $3) }
btype :: { LHsType RdrName }
: btype atype { LL $ HsAppTy $1 $2 }
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)) } }
| 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
- (GRHSs (unguardedRHS $6) emptyLocalBinds
- )])) }
+ : '\\' 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)) }
: 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 }
| 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)) }
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
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) }
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) }
projects / ghc-hetmet.git / blobdiff