X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2FhsSyn%2FHsExpr.lhs;h=3654de17443c05634187b1db4afcc28f1308aa95;hb=1e50fd4185479a62e02d987bdfcb1c62712859ca;hp=66336b628c25af521458bad558fce9603be04f78;hpb=259d5ea8479dbbf0220335c740efebec1bc19a7f;p=ghc-hetmet.git diff --git a/compiler/hsSyn/HsExpr.lhs b/compiler/hsSyn/HsExpr.lhs index 66336b6..3654de1 100644 --- a/compiler/hsSyn/HsExpr.lhs +++ b/compiler/hsSyn/HsExpr.lhs @@ -121,6 +121,10 @@ data HsExpr id | SectionR (LHsExpr id) -- operator (LHsExpr id) -- operand + | ExplicitTuple -- Used for explicit tuples and sections thereof + [HsTupArg id] + Boxity + | HsCase (LHsExpr id) (MatchGroup id) @@ -147,14 +151,6 @@ data HsExpr id PostTcType -- type of elements of the parallel array [LHsExpr id] - | ExplicitTuple -- tuple - [LHsExpr id] - -- NB: Unit is ExplicitTuple [] - -- for tuples, we can get the types - -- direct from the components - Boxity - - -- Record construction | RecordCon (Located id) -- The constructor. After type checking -- it's the dataConWrapId of the constructor @@ -280,6 +276,17 @@ data HsExpr id | HsWrap HsWrapper -- TRANSLATION (HsExpr id) +-- HsTupArg is used for tuple sections +-- (,a,) is represented by ExplicitTuple [Mising ty1, Present a, Missing ty3] +-- Which in turn stands for (\x:ty1 \y:ty2. (x,a,y)) +data HsTupArg id + = Present (LHsExpr id) -- The argument + | Missing PostTcType -- The argument is missing, but this is its type + +tupArgPresent :: HsTupArg id -> Bool +tupArgPresent (Present {}) = True +tupArgPresent (Missing {}) = False + type PendingSplice = (Name, LHsExpr Id) -- Typechecked splices, waiting to be -- pasted back in by the desugarer \end{code} @@ -380,6 +387,17 @@ ppr_expr (SectionR op expr) pp_infixly v = (sep [pprHsInfix v, pp_expr]) +ppr_expr (ExplicitTuple exprs boxity) + = tupleParens boxity (fcat (ppr_tup_args exprs)) + where + ppr_tup_args [] = [] + ppr_tup_args (Present e : es) = (ppr_lexpr e <> punc es) : ppr_tup_args es + ppr_tup_args (Missing _ : es) = punc es : ppr_tup_args es + + punc (Present {} : _) = comma <> space + punc (Missing {} : _) = comma + punc [] = empty + --avoid using PatternSignatures for stage1 code portability ppr_expr exprType@(HsLam matches) = pprMatches (LambdaExpr `asTypeOf` idType exprType) matches @@ -413,9 +431,6 @@ ppr_expr (ExplicitList _ exprs) ppr_expr (ExplicitPArr _ exprs) = pa_brackets (pprDeeperList fsep (punctuate comma (map ppr_lexpr exprs))) -ppr_expr (ExplicitTuple exprs boxity) - = tupleParens boxity (sep (punctuate comma (map ppr_lexpr exprs))) - ppr_expr (RecordCon con_id _ rbinds) = hang (ppr con_id) 2 (ppr rbinds) @@ -529,16 +544,18 @@ pprParendExpr expr -- I think that is usually (always?) right in case unLoc expr of - HsLit _ -> pp_as_was - HsOverLit _ -> pp_as_was - HsVar _ -> pp_as_was - HsIPVar _ -> pp_as_was - ExplicitList _ _ -> pp_as_was - ExplicitPArr _ _ -> pp_as_was - ExplicitTuple _ _ -> pp_as_was - HsPar _ -> pp_as_was - HsBracket _ -> pp_as_was - HsBracketOut _ [] -> pp_as_was + ArithSeq {} -> pp_as_was + PArrSeq {} -> pp_as_was + HsLit {} -> pp_as_was + HsOverLit {} -> pp_as_was + HsVar {} -> pp_as_was + HsIPVar {} -> pp_as_was + ExplicitTuple {} -> pp_as_was + ExplicitList {} -> pp_as_was + ExplicitPArr {} -> pp_as_was + HsPar {} -> pp_as_was + HsBracket {} -> pp_as_was + HsBracketOut _ [] -> pp_as_was HsDo sc _ _ _ | isListCompExpr sc -> pp_as_was _ -> parens pp_as_was @@ -922,12 +939,19 @@ pprGroupByClause (GroupBySomething eitherUsingExpr byExpr) = hsep [ptext (sLit " where usingExprDoc = either (\usingExpr -> hsep [ptext (sLit "using"), ppr usingExpr]) (const empty) eitherUsingExpr pprDo :: OutputableBndr id => HsStmtContext any -> [LStmt id] -> LHsExpr id -> SDoc -pprDo DoExpr stmts body = ptext (sLit "do") <+> pprDeeperList vcat (map ppr stmts ++ [ppr body]) -pprDo (MDoExpr _) stmts body = ptext (sLit "mdo") <+> pprDeeperList vcat (map ppr stmts ++ [ppr body]) +pprDo DoExpr stmts body = ptext (sLit "do") <+> ppr_do_stmts stmts body +pprDo (MDoExpr _) stmts body = ptext (sLit "mdo") <+> ppr_do_stmts stmts body pprDo ListComp stmts body = pprComp brackets stmts body pprDo PArrComp stmts body = pprComp pa_brackets stmts body pprDo _ _ _ = panic "pprDo" -- PatGuard, ParStmtCxt +ppr_do_stmts :: OutputableBndr id => [LStmt id] -> LHsExpr id -> SDoc +-- Print a bunch of do stmts, with explicit braces and semicolons, +-- so that we are not vulnerable to layout bugs +ppr_do_stmts stmts body + = lbrace <+> pprDeeperList vcat ([ ppr s <> semi | s <- stmts] ++ [ppr body]) + <+> rbrace + pprComp :: OutputableBndr id => (SDoc -> SDoc) -> [LStmt id] -> LHsExpr id -> SDoc pprComp brack quals body = brack $ @@ -1105,20 +1129,20 @@ pprStmtResultContext other = ptext (sLit "the result of") <+> pprStmtC -} -- Used to generate the string for a *runtime* error message -matchContextErrString :: Outputable id => HsMatchContext id -> String -matchContextErrString (FunRhs fun _) = "function " ++ showSDoc (ppr fun) -matchContextErrString CaseAlt = "case" -matchContextErrString PatBindRhs = "pattern binding" -matchContextErrString RecUpd = "record update" -matchContextErrString LambdaExpr = "lambda" -matchContextErrString ProcExpr = "proc" +matchContextErrString :: Outputable id => HsMatchContext id -> SDoc +matchContextErrString (FunRhs fun _) = ptext (sLit "function") <+> ppr fun +matchContextErrString CaseAlt = ptext (sLit "case") +matchContextErrString PatBindRhs = ptext (sLit "pattern binding") +matchContextErrString RecUpd = ptext (sLit "record update") +matchContextErrString LambdaExpr = ptext (sLit "lambda") +matchContextErrString ProcExpr = ptext (sLit "proc") matchContextErrString (StmtCtxt (ParStmtCtxt c)) = matchContextErrString (StmtCtxt c) matchContextErrString (StmtCtxt (TransformStmtCtxt c)) = matchContextErrString (StmtCtxt c) -matchContextErrString (StmtCtxt (PatGuard _)) = "pattern guard" -matchContextErrString (StmtCtxt DoExpr) = "'do' expression" -matchContextErrString (StmtCtxt (MDoExpr _)) = "'mdo' expression" -matchContextErrString (StmtCtxt ListComp) = "list comprehension" -matchContextErrString (StmtCtxt PArrComp) = "array comprehension" +matchContextErrString (StmtCtxt (PatGuard _)) = ptext (sLit "pattern guard") +matchContextErrString (StmtCtxt DoExpr) = ptext (sLit "'do' expression") +matchContextErrString (StmtCtxt (MDoExpr _)) = ptext (sLit "'mdo' expression") +matchContextErrString (StmtCtxt ListComp) = ptext (sLit "list comprehension") +matchContextErrString (StmtCtxt PArrComp) = ptext (sLit "array comprehension") \end{code} \begin{code}