X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fparser%2FParser.y.pp;h=4cd637fb341d6b751f57bc75751b21571dba5361;hp=f051726b760b4ff0c240e42c03406801a3241eaf;hb=d8b99b7e9b2ce9fd8ba97fa10657082ceac09c59;hpb=63489d40bdee972656ff115ab2309b809c0e39fc diff --git a/compiler/parser/Parser.y.pp b/compiler/parser/Parser.y.pp index f051726..4cd637f 100644 --- a/compiler/parser/Parser.y.pp +++ b/compiler/parser/Parser.y.pp @@ -48,7 +48,7 @@ import StaticFlags ( opt_SccProfilingOn, opt_Hpc ) import Type ( Kind, mkArrowKind, liftedTypeKind, unliftedTypeKind ) import Class ( FunDep ) import BasicTypes ( Boxity(..), Fixity(..), FixityDirection(..), IPName(..), - Activation(..), RuleMatchInfo(..), defaultInlineSpec ) + Activation(..), RuleMatchInfo(..), defaultInlinePragma ) import DynFlags import OrdList import HaddockUtils @@ -262,9 +262,9 @@ incorrect. '{-# SCC' { L _ ITscc_prag } '{-# GENERATED' { L _ ITgenerated_prag } '{-# DEPRECATED' { L _ ITdeprecated_prag } - '{-# WARNING' { L _ ITwarning_prag } + '{-# WARNING' { L _ ITwarning_prag } '{-# UNPACK' { L _ ITunpack_prag } - '{-# ANN' { L _ ITann_prag } + '{-# ANN' { L _ ITann_prag } '#-}' { L _ ITclose_prag } '..' { L _ ITdotdot } -- reserved symbols @@ -559,17 +559,17 @@ topdecl :: { OrdList (LHsDecl RdrName) } | stand_alone_deriving { unitOL (LL (DerivD (unLoc $1))) } | 'default' '(' comma_types0 ')' { unitOL (LL $ DefD (DefaultDecl $3)) } | 'foreign' fdecl { unitOL (LL (unLoc $2)) } - | '{-# DEPRECATED' deprecations '#-}' { $2 } - | '{-# WARNING' warnings '#-}' { $2 } + | '{-# DEPRECATED' deprecations '#-}' { $2 } + | '{-# WARNING' warnings '#-}' { $2 } | '{-# RULES' rules '#-}' { $2 } | annotation { unitOL $1 } | decl { unLoc $1 } -- Template Haskell Extension - | '$(' exp ')' { unitOL (LL $ SpliceD (SpliceDecl $2)) } - | TH_ID_SPLICE { unitOL (LL $ SpliceD (SpliceDecl $ - L1 $ HsVar (mkUnqual varName (getTH_ID_SPLICE $1)) - )) } + -- The $(..) form is one possible form of infixexp + -- but we treat an arbitrary expression just as if + -- it had a $(..) wrapped around it + | infixexp { unitOL (LL $ mkTopSpliceDecl $1) } -- Type classes -- @@ -611,10 +611,10 @@ ty_decl :: { LTyClDecl RdrName } -- ordinary GADT declaration | data_or_newtype tycl_hdr opt_kind_sig - 'where' gadt_constrlist + gadt_constrlist deriving {% mkTyData (comb4 $1 $2 $4 $5) (unLoc $1) False $2 - (unLoc $3) (reverse (unLoc $5)) (unLoc $6) } + (unLoc $3) (unLoc $4) (unLoc $5) } -- We need the location on tycl_hdr in case -- constrs and deriving are both empty @@ -629,10 +629,10 @@ ty_decl :: { LTyClDecl RdrName } -- GADT instance declaration | data_or_newtype 'instance' tycl_hdr opt_kind_sig - 'where' gadt_constrlist + gadt_constrlist deriving - {% mkTyData (comb4 $1 $3 $6 $7) (unLoc $1) True $3 - (unLoc $4) (reverse (unLoc $6)) (unLoc $7) } + {% mkTyData (comb4 $1 $3 $5 $6) (unLoc $1) True $3 + (unLoc $4) (unLoc $5) (unLoc $6) } -- Associated type family declarations -- @@ -676,10 +676,10 @@ at_decl_inst :: { LTyClDecl RdrName } -- GADT instance declaration | data_or_newtype tycl_hdr opt_kind_sig - 'where' gadt_constrlist + gadt_constrlist deriving - {% mkTyData (comb4 $1 $2 $5 $6) (unLoc $1) True $2 - (unLoc $3) (reverse (unLoc $5)) (unLoc $6) } + {% mkTyData (comb4 $1 $2 $4 $5) (unLoc $1) True $2 + (unLoc $3) (unLoc $4) (unLoc $5) } data_or_newtype :: { Located NewOrData } : 'data' { L1 DataType } @@ -981,7 +981,7 @@ context :: { LHsContext RdrName } type :: { LHsType RdrName } : btype { $1 } - | btype qtyconop type { LL $ HsOpTy $1 $2 $3 } + | btype qtyconop type { LL $ HsOpTy $1 $2 $3 } | btype tyvarop type { LL $ HsOpTy $1 $2 $3 } | btype '->' ctype { LL $ HsFunTy $1 $3 } | btype '~' btype { LL $ HsPredTy (HsEqualP $1 $3) } @@ -1079,14 +1079,15 @@ akind :: { Located Kind } ----------------------------------------------------------------------------- -- Datatype declarations -gadt_constrlist :: { Located [LConDecl RdrName] } - : '{' gadt_constrs '}' { LL (unLoc $2) } - | vocurly gadt_constrs close { $2 } +gadt_constrlist :: { Located [LConDecl RdrName] } -- Returned in order + : 'where' '{' gadt_constrs '}' { L (comb2 $1 $3) (unLoc $3) } + | 'where' vocurly gadt_constrs close { L (comb2 $1 $3) (unLoc $3) } + | {- empty -} { noLoc [] } gadt_constrs :: { Located [LConDecl RdrName] } - : gadt_constrs ';' gadt_constr { sL (comb2 $1 (head $3)) ($3 ++ unLoc $1) } - | gadt_constrs ';' { $1 } - | gadt_constr { sL (getLoc (head $1)) $1 } + : gadt_constr ';' gadt_constrs { L (comb2 (head $1) $3) ($1 ++ unLoc $3) } + | gadt_constr { L (getLoc (head $1)) $1 } + | {- empty -} { noLoc [] } -- We allow the following forms: -- C :: Eq a => a -> T a @@ -1094,7 +1095,7 @@ gadt_constrs :: { Located [LConDecl RdrName] } -- D { x,y :: a } :: T a -- forall a. Eq a => D { x,y :: a } :: T a -gadt_constr :: { [LConDecl RdrName] } +gadt_constr :: { [LConDecl RdrName] } -- Returns a list because of: C,D :: ty : con_list '::' sigtype { map (sL (comb2 $1 $3)) (mkGadtDecl (unLoc $1) $3) } @@ -1104,8 +1105,7 @@ gadt_constr :: { [LConDecl RdrName] } ; return [cd] } } constrs :: { Located [LConDecl RdrName] } - : {- empty; a GHC extension -} { noLoc [] } - | maybe_docnext '=' constrs1 { L (comb2 $2 $3) (addConDocs (unLoc $3) $1) } + : maybe_docnext '=' constrs1 { L (comb2 $2 $3) (addConDocs (unLoc $3) $1) } constrs1 :: { Located [LConDecl RdrName] } : constrs1 maybe_docnext '|' maybe_docprev constr { LL (addConDoc $5 $2 : addConDocFirst (unLoc $1) $4) } @@ -1228,17 +1228,17 @@ sigdecl :: { Located (OrdList (LHsDecl RdrName)) } | infix prec ops { LL $ toOL [ LL $ SigD (FixSig (FixitySig n (Fixity $2 (unLoc $1)))) | n <- unLoc $3 ] } | '{-# INLINE' activation qvar '#-}' - { LL $ unitOL (LL $ SigD (InlineSig $3 (mkInlineSpec $2 FunLike (getINLINE $1)))) } + { LL $ unitOL (LL $ SigD (InlineSig $3 (mkInlinePragma $2 FunLike (getINLINE $1)))) } | '{-# INLINE_CONLIKE' activation qvar '#-}' - { LL $ unitOL (LL $ SigD (InlineSig $3 (mkInlineSpec $2 ConLike (getINLINE_CONLIKE $1)))) } + { LL $ unitOL (LL $ SigD (InlineSig $3 (mkInlinePragma $2 ConLike (getINLINE_CONLIKE $1)))) } | '{-# SPECIALISE' qvar '::' sigtypes1 '#-}' - { LL $ toOL [ LL $ SigD (SpecSig $2 t defaultInlineSpec) + { LL $ toOL [ LL $ SigD (SpecSig $2 t defaultInlinePragma) | t <- $4] } | '{-# SPECIALISE_INLINE' activation qvar '::' sigtypes1 '#-}' - { LL $ toOL [ LL $ SigD (SpecSig $3 t (mkInlineSpec $2 FunLike (getSPEC_INLINE $1))) + { LL $ toOL [ LL $ SigD (SpecSig $3 t (mkInlinePragma $2 FunLike (getSPEC_INLINE $1))) | t <- $5] } | '{-# SPECIALISE' 'instance' inst_type '#-}' - { LL $ unitOL (LL $ SigD (SpecInstSig $3)) } + { LL $ unitOL (LL $ SigD (SpecInstSig $3)) } ----------------------------------------------------------------------------- -- Expressions @@ -1456,35 +1456,27 @@ lexps :: { Located [LHsExpr RdrName] } flattenedpquals :: { Located [LStmt RdrName] } : pquals { case (unLoc $1) of - ParStmt [(qs, _)] -> L1 qs + [qs] -> L1 qs -- We just had one thing in our "parallel" list so -- we simply return that thing directly - _ -> L1 [$1] + qss -> L1 [L1 $ ParStmt [(qs, undefined) | qs <- qss]] -- We actually found some actual parallel lists so - -- we leave them into as a ParStmt + -- we wrap them into as a ParStmt } -pquals :: { LStmt RdrName } - : pquals1 { L1 (ParStmt [(qs, undefined) | qs <- (reverse (unLoc $1))]) } +pquals :: { Located [[LStmt RdrName]] } + : squals '|' pquals { L (getLoc $2) (reverse (unLoc $1) : unLoc $3) } + | squals { L (getLoc $1) [reverse (unLoc $1)] } -pquals1 :: { Located [[LStmt RdrName]] } - : pquals1 '|' squals { LL (unLoc $3 : unLoc $1) } - | squals { L (getLoc $1) [unLoc $1] } - -squals :: { Located [LStmt RdrName] } - : squals1 { L (getLoc $1) (reverse (unLoc $1)) } - -squals1 :: { Located [LStmt RdrName] } - : transformquals1 { LL (unLoc $1) } - -transformquals1 :: { Located [LStmt RdrName] } - : transformquals1 ',' transformqual { LL $ [LL ((unLoc $3) (unLoc $1))] } - | transformquals1 ',' qual { LL ($3 : unLoc $1) } --- | transformquals1 ',' '{|' pquals '|}' { LL ($4 : unLoc $1) } - | transformqual { LL $ [LL ((unLoc $1) [])] } - | qual { L1 [$1] } --- | '{|' pquals '|}' { L1 [$2] } +squals :: { Located [LStmt RdrName] } -- In reverse order, because the last + -- one can "grab" the earlier ones + : squals ',' transformqual { LL [L (getLoc $3) ((unLoc $3) (reverse (unLoc $1)))] } + | squals ',' qual { LL ($3 : unLoc $1) } + | transformqual { LL [L (getLoc $1) ((unLoc $1) [])] } + | qual { L1 [$1] } +-- | transformquals1 ',' '{|' pquals '|}' { LL ($4 : unLoc $1) } +-- | '{|' pquals '|}' { L1 [$2] } -- It is possible to enable bracketing (associating) qualifier lists by uncommenting the lines with {| |} @@ -1493,10 +1485,11 @@ transformquals1 :: { Located [LStmt RdrName] } -- a program that makes use of this temporary syntax you must supply that flag to GHC transformqual :: { Located ([LStmt RdrName] -> Stmt RdrName) } - : 'then' exp { LL $ \leftStmts -> (mkTransformStmt (reverse leftStmts) $2) } + -- Function is applied to a list of stmts *in order* + : 'then' exp { LL $ \leftStmts -> (mkTransformStmt leftStmts $2) } -- >>> - | 'then' exp 'by' exp { LL $ \leftStmts -> (mkTransformByStmt (reverse leftStmts) $2 $4) } - | 'then' 'group' 'by' exp { LL $ \leftStmts -> (mkGroupByStmt (reverse leftStmts) $4) } + | 'then' exp 'by' exp { LL $ \leftStmts -> (mkTransformByStmt leftStmts $2 $4) } + | 'then' 'group' 'by' exp { LL $ \leftStmts -> (mkGroupByStmt leftStmts $4) } -- <<< -- These two productions deliberately have a shift-reduce conflict. I have made 'group' into a special_id, -- which means you can enable TransformListComp while still using Data.List.group. However, this makes the two @@ -1506,8 +1499,8 @@ transformqual :: { Located ([LStmt RdrName] -> Stmt RdrName) } -- This is rather dubious: the user might be confused as to how to parse this statement. However, it is a good -- practical choice. NB: Data.List.group :: [a] -> [[a]], so using the first production would not even type check -- if /that/ is the group function we conflict with. - | 'then' 'group' 'using' exp { LL $ \leftStmts -> (mkGroupUsingStmt (reverse leftStmts) $4) } - | 'then' 'group' 'by' exp 'using' exp { LL $ \leftStmts -> (mkGroupByUsingStmt (reverse leftStmts) $4 $6) } + | 'then' 'group' 'using' exp { LL $ \leftStmts -> (mkGroupUsingStmt leftStmts $4) } + | 'then' 'group' 'by' exp 'using' exp { LL $ \leftStmts -> (mkGroupByUsingStmt leftStmts $4 $6) } ----------------------------------------------------------------------------- -- Parallel array expressions @@ -2019,6 +2012,6 @@ sL span a = span `seq` a `seq` L span a fileSrcSpan :: P SrcSpan fileSrcSpan = do l <- getSrcLoc; - let loc = mkSrcLoc (srcLocFile l) 1 0; + let loc = mkSrcLoc (srcLocFile l) 1 1; return (mkSrcSpan loc loc) }