X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcExpr.lhs;h=27b4cf15a150a23f6f796a5f711f6b334b3aa181;hp=4151e0d1f2366a1f70e65aee41b5b52bb123cf9d;hb=3f1b316d7035c55cd712cd39a9981339bcef2e8c;hpb=102b73a3f2a2f63d3835726be625dca8053dd88c diff --git a/compiler/typecheck/TcExpr.lhs b/compiler/typecheck/TcExpr.lhs index 4151e0d..27b4cf1 100644 --- a/compiler/typecheck/TcExpr.lhs +++ b/compiler/typecheck/TcExpr.lhs @@ -5,8 +5,14 @@ \section[TcExpr]{Typecheck an expression} \begin{code} -module TcExpr ( tcPolyExpr, tcPolyExprNC, - tcMonoExpr, tcInferRho, tcSyntaxOp ) where +{-# OPTIONS -w #-} +-- The above warning supression flag is a temporary kludge. +-- While working on this module you are encouraged to remove it and fix +-- any warnings in the module. See +-- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings +-- for details + +module TcExpr ( tcPolyExpr, tcPolyExprNC, tcMonoExpr, tcInferRho, tcSyntaxOp) where #include "HsVersions.h" @@ -29,11 +35,14 @@ import TcHsType import TcPat import TcMType import TcType +import TcIface ( checkWiredInTyCon ) import Id import DataCon import Name import TyCon import Type +import TypeRep +import Coercion import Var import VarSet import TysWiredIn @@ -69,11 +78,12 @@ tcPolyExpr, tcPolyExprNC tcPolyExpr expr res_ty = addErrCtxt (exprCtxt (unLoc expr)) $ - tcPolyExprNC expr res_ty + (do {traceTc (text "tcPolyExpr") ; tcPolyExprNC expr res_ty }) tcPolyExprNC expr res_ty | isSigmaTy res_ty - = do { (gen_fn, expr') <- tcGen res_ty emptyVarSet (\_ -> tcPolyExprNC expr) + = do { traceTc (text "tcPolyExprNC" <+> ppr res_ty) + ; (gen_fn, expr') <- tcGen res_ty emptyVarSet (\_ -> tcPolyExprNC expr) -- Note the recursive call to tcPolyExpr, because the -- type may have multiple layers of for-alls -- E.g. forall a. Eq a => forall b. Ord b => .... @@ -110,7 +120,6 @@ tcInferRho expr = tcInfer (tcMonoExpr expr) \end{code} - %************************************************************************ %* * tcExpr: the main expression typechecker @@ -121,8 +130,10 @@ tcInferRho expr = tcInfer (tcMonoExpr expr) tcExpr :: HsExpr Name -> BoxyRhoType -> TcM (HsExpr TcId) tcExpr (HsVar name) res_ty = tcId (OccurrenceOf name) name res_ty -tcExpr (HsLit lit) res_ty = do { boxyUnify (hsLitType lit) res_ty - ; return (HsLit lit) } +tcExpr (HsLit lit) res_ty = do { let lit_ty = hsLitType lit + ; coi <- boxyUnify lit_ty res_ty + ; return $ mkHsWrapCoI coi (HsLit lit) + } tcExpr (HsPar expr) res_ty = do { expr' <- tcMonoExpr expr res_ty ; return (HsPar expr') } @@ -166,6 +177,7 @@ tcExpr (HsApp e1 e2) res_ty go lfun@(L loc fun) args = do { (fun', args') <- -- addErrCtxt (callCtxt lfun args) $ tcApp fun (length args) (tcArgs lfun args) res_ty + ; traceTc (text "tcExpr args': " <+> ppr args') ; return (unLoc (foldl mkHsApp (L loc fun') args')) } tcExpr (HsLam match) res_ty @@ -276,21 +288,21 @@ tcExpr (HsDo do_or_lc stmts body _) res_ty = tcDoStmts do_or_lc stmts body res_ty tcExpr in_expr@(ExplicitList _ exprs) res_ty -- Non-empty list - = do { elt_ty <- boxySplitListTy res_ty + = do { (elt_ty, coi) <- boxySplitListTy res_ty ; exprs' <- mappM (tc_elt elt_ty) exprs - ; return (ExplicitList elt_ty exprs') } + ; return $ mkHsWrapCoI coi (ExplicitList elt_ty exprs') } where tc_elt elt_ty expr = tcPolyExpr expr elt_ty tcExpr in_expr@(ExplicitPArr _ exprs) res_ty -- maybe empty - = do { [elt_ty] <- boxySplitTyConApp parrTyCon res_ty + = do { (elt_ty, coi) <- boxySplitPArrTy res_ty ; exprs' <- mappM (tc_elt elt_ty) exprs ; ifM (null exprs) (zapToMonotype elt_ty) -- If there are no expressions in the comprehension -- we must still fill in the box -- (Not needed for [] and () becuase they happen -- to parse as data constructors.) - ; return (ExplicitPArr elt_ty exprs') } + ; return $ mkHsWrapCoI coi (ExplicitPArr elt_ty exprs') } where tc_elt elt_ty expr = tcPolyExpr expr elt_ty @@ -302,15 +314,16 @@ tcExpr (ExplicitTuple exprs boxity) res_ty = do { tvs <- newBoxyTyVars [argTypeKind | e <- exprs] ; let tup_tc = tupleTyCon boxity (length exprs) tup_res_ty = mkTyConApp tup_tc (mkTyVarTys tvs) - ; arg_tys <- preSubType tvs (mkVarSet tvs) tup_res_ty res_ty - ; exprs' <- tcPolyExprs exprs arg_tys + ; checkWiredInTyCon tup_tc -- Ensure instances are available + ; arg_tys <- preSubType tvs (mkVarSet tvs) tup_res_ty res_ty + ; exprs' <- tcPolyExprs exprs arg_tys ; arg_tys' <- mapM refineBox arg_tys - ; co_fn <- tcFunResTy (tyConName tup_tc) (mkTyConApp tup_tc arg_tys') res_ty + ; co_fn <- tcFunResTy (tyConName tup_tc) (mkTyConApp tup_tc arg_tys') res_ty ; return (mkHsWrap co_fn (ExplicitTuple exprs' boxity)) } tcExpr (HsProc pat cmd) res_ty - = do { (pat', cmd') <- tcProc pat cmd res_ty - ; return (HsProc pat' cmd') } + = do { (pat', cmd', coi) <- tcProc pat cmd res_ty + ; return $ mkHsWrapCoI coi (HsProc pat' cmd') } tcExpr e@(HsArrApp _ _ _ _ _) _ = failWithTc (vcat [ptext SLIT("The arrow command"), nest 2 (ppr e), @@ -382,20 +395,21 @@ tcExpr expr@(RecordCon (L loc con_name) _ rbinds) res_ty -- don't know how to do the update otherwise. -tcExpr expr@(RecordUpd record_expr hrbinds@(HsRecordBinds rbinds) _ _) res_ty +tcExpr expr@(RecordUpd record_expr rbinds _ _ _) res_ty = -- STEP 0 -- Check that the field names are really field names - ASSERT( notNull rbinds ) let - field_names = map fst rbinds + field_names = hsRecFields rbinds in - mappM (tcLookupField . unLoc) field_names `thenM` \ sel_ids -> + ASSERT( notNull field_names ) + mappM tcLookupField field_names `thenM` \ sel_ids -> -- The renamer has already checked that they -- are all in scope let bad_guys = [ setSrcSpan loc $ addErrTc (notSelector field_name) - | (L loc field_name, sel_id) <- field_names `zip` sel_ids, - not (isRecordSelector sel_id) -- Excludes class ops + | (fld, sel_id) <- rec_flds rbinds `zip` sel_ids, + not (isRecordSelector sel_id), -- Excludes class ops + let L loc field_name = hsRecFieldId fld ] in checkM (null bad_guys) (sequenceM bad_guys `thenM_` failM) `thenM_` @@ -404,19 +418,20 @@ tcExpr expr@(RecordUpd record_expr hrbinds@(HsRecordBinds rbinds) _ _) res_ty -- Figure out the tycon and data cons from the first field name let -- It's OK to use the non-tc splitters here (for a selector) - upd_field_lbls = recBindFields hrbinds sel_id : _ = sel_ids (tycon, _) = recordSelectorFieldLabel sel_id -- We've failed already if - data_cons = tyConDataCons tycon -- it's not a field label + data_cons = tyConDataCons tycon -- it's not a field label + -- NB: for a data type family, the tycon is the instance tycon + relevant_cons = filter is_relevant data_cons - is_relevant con = all (`elem` dataConFieldLabels con) upd_field_lbls + is_relevant con = all (`elem` dataConFieldLabels con) field_names in -- STEP 2 -- Check that at least one constructor has all the named fields -- i.e. has an empty set of bad fields returned by badFields checkTc (not (null relevant_cons)) - (badFieldsUpd hrbinds) `thenM_` + (badFieldsUpd rbinds) `thenM_` -- Check that all relevant data cons are vanilla. Doing record updates on -- GADTs and/or existentials is more than my tiny brain can cope with today @@ -432,12 +447,11 @@ tcExpr expr@(RecordUpd record_expr hrbinds@(HsRecordBinds rbinds) _ _) res_ty let -- A constructor is only relevant to this process if -- it contains *all* the fields that are being updated - con1 = head relevant_cons -- A representative constructor - con1_tyvars = dataConUnivTyVars con1 - con1_flds = dataConFieldLabels con1 - con1_arg_tys = dataConOrigArgTys con1 - common_tyvars = exactTyVarsOfTypes [ty | (fld,ty) <- con1_flds `zip` con1_arg_tys - , not (fld `elem` upd_field_lbls) ] + con1 = ASSERT( not (null relevant_cons) ) head relevant_cons -- A representative constructor + (con1_tyvars, theta, con1_arg_tys, con1_res_ty) = dataConSig con1 + con1_flds = dataConFieldLabels con1 + common_tyvars = exactTyVarsOfTypes [ty | (fld,ty) <- con1_flds `zip` con1_arg_tys + , not (fld `elem` field_names) ] is_common_tv tv = tv `elemVarSet` common_tyvars @@ -445,43 +459,48 @@ tcExpr expr@(RecordUpd record_expr hrbinds@(HsRecordBinds rbinds) _ _) res_ty | is_common_tv tv = returnM result_inst_ty -- Same as result type | otherwise = newFlexiTyVarTy (tyVarKind tv) -- Fresh type, of correct kind in - tcInstTyVars con1_tyvars `thenM` \ (_, result_inst_tys, inst_env) -> - zipWithM mk_inst_ty con1_tyvars result_inst_tys `thenM` \ inst_tys -> + ASSERT( null theta ) -- Vanilla datacon + tcInstTyVars con1_tyvars `thenM` \ (_, result_inst_tys, result_inst_env) -> + zipWithM mk_inst_ty con1_tyvars result_inst_tys `thenM` \ scrut_inst_tys -> - -- STEP 3 - -- Typecheck the update bindings. - -- (Do this after checking for bad fields in case there's a field that - -- doesn't match the constructor.) + -- STEP 3: Typecheck the update bindings. + -- Do this after checking for bad fields in case + -- there's a field that doesn't match the constructor. let - result_record_ty = mkTyConApp tycon result_inst_tys - con1_arg_tys' = map (substTy inst_env) con1_arg_tys + result_ty = substTy result_inst_env con1_res_ty + con1_arg_tys' = map (substTy result_inst_env) con1_arg_tys in - tcSubExp result_record_ty res_ty `thenM` \ co_fn -> - tcRecordBinds con1 con1_arg_tys' hrbinds `thenM` \ rbinds' -> + tcSubExp result_ty res_ty `thenM` \ co_fn -> + tcRecordBinds con1 con1_arg_tys' rbinds `thenM` \ rbinds' -> - -- STEP 5 - -- Typecheck the expression to be updated + -- STEP 5: Typecheck the expression to be updated let - record_ty = ASSERT( length inst_tys == tyConArity tycon ) - mkTyConApp tycon inst_tys + scrut_inst_env = zipTopTvSubst con1_tyvars scrut_inst_tys + scrut_ty = substTy scrut_inst_env con1_res_ty -- This is one place where the isVanilla check is important - -- So that inst_tys matches the tycon + -- So that inst_tys matches the con1_tyvars in - tcMonoExpr record_expr record_ty `thenM` \ record_expr' -> + tcMonoExpr record_expr scrut_ty `thenM` \ record_expr' -> - -- STEP 6 - -- Figure out the LIE we need. We have to generate some - -- dictionaries for the data type context, since we are going to - -- do pattern matching over the data cons. + -- STEP 6: Figure out the LIE we need. + -- We have to generate some dictionaries for the data type context, + -- since we are going to do pattern matching over the data cons. -- - -- What dictionaries do we need? The tyConStupidTheta tells us. + -- What dictionaries do we need? The dataConStupidTheta tells us. let - theta' = substTheta inst_env (tyConStupidTheta tycon) + theta' = substTheta scrut_inst_env (dataConStupidTheta con1) in instStupidTheta RecordUpdOrigin theta' `thenM_` + -- Step 7: make a cast for the scrutinee, in the case that it's from a type family + let scrut_co | Just co_con <- tyConFamilyCoercion_maybe tycon + = WpCo $ mkTyConApp co_con scrut_inst_tys + | otherwise + = idHsWrapper + in -- Phew! - returnM (mkHsWrap co_fn (RecordUpd record_expr' rbinds' record_ty result_record_ty)) + returnM (mkHsWrap co_fn (RecordUpd (mkLHsWrap scrut_co record_expr') rbinds' + relevant_cons scrut_inst_tys result_inst_tys)) \end{code} @@ -495,54 +514,58 @@ tcExpr expr@(RecordUpd record_expr hrbinds@(HsRecordBinds rbinds) _ _) res_ty \begin{code} tcExpr (ArithSeq _ seq@(From expr)) res_ty - = do { elt_ty <- boxySplitListTy res_ty + = do { (elt_ty, coi) <- boxySplitListTy res_ty ; expr' <- tcPolyExpr expr elt_ty ; enum_from <- newMethodFromName (ArithSeqOrigin seq) elt_ty enumFromName - ; return (ArithSeq (HsVar enum_from) (From expr')) } + ; return $ mkHsWrapCoI coi (ArithSeq (HsVar enum_from) (From expr')) } tcExpr in_expr@(ArithSeq _ seq@(FromThen expr1 expr2)) res_ty - = do { elt_ty <- boxySplitListTy res_ty + = do { (elt_ty, coi) <- boxySplitListTy res_ty ; expr1' <- tcPolyExpr expr1 elt_ty ; expr2' <- tcPolyExpr expr2 elt_ty ; enum_from_then <- newMethodFromName (ArithSeqOrigin seq) elt_ty enumFromThenName - ; return (ArithSeq (HsVar enum_from_then) (FromThen expr1' expr2')) } - + ; return $ mkHsWrapCoI coi + (ArithSeq (HsVar enum_from_then) (FromThen expr1' expr2')) } tcExpr in_expr@(ArithSeq _ seq@(FromTo expr1 expr2)) res_ty - = do { elt_ty <- boxySplitListTy res_ty + = do { (elt_ty, coi) <- boxySplitListTy res_ty ; expr1' <- tcPolyExpr expr1 elt_ty ; expr2' <- tcPolyExpr expr2 elt_ty ; enum_from_to <- newMethodFromName (ArithSeqOrigin seq) elt_ty enumFromToName - ; return (ArithSeq (HsVar enum_from_to) (FromTo expr1' expr2')) } + ; return $ mkHsWrapCoI coi + (ArithSeq (HsVar enum_from_to) (FromTo expr1' expr2')) } tcExpr in_expr@(ArithSeq _ seq@(FromThenTo expr1 expr2 expr3)) res_ty - = do { elt_ty <- boxySplitListTy res_ty + = do { (elt_ty, coi) <- boxySplitListTy res_ty ; expr1' <- tcPolyExpr expr1 elt_ty ; expr2' <- tcPolyExpr expr2 elt_ty ; expr3' <- tcPolyExpr expr3 elt_ty ; eft <- newMethodFromName (ArithSeqOrigin seq) elt_ty enumFromThenToName - ; return (ArithSeq (HsVar eft) (FromThenTo expr1' expr2' expr3')) } + ; return $ mkHsWrapCoI coi + (ArithSeq (HsVar eft) (FromThenTo expr1' expr2' expr3')) } tcExpr in_expr@(PArrSeq _ seq@(FromTo expr1 expr2)) res_ty - = do { [elt_ty] <- boxySplitTyConApp parrTyCon res_ty + = do { (elt_ty, coi) <- boxySplitPArrTy res_ty ; expr1' <- tcPolyExpr expr1 elt_ty ; expr2' <- tcPolyExpr expr2 elt_ty ; enum_from_to <- newMethodFromName (PArrSeqOrigin seq) elt_ty enumFromToPName - ; return (PArrSeq (HsVar enum_from_to) (FromTo expr1' expr2')) } + ; return $ mkHsWrapCoI coi + (PArrSeq (HsVar enum_from_to) (FromTo expr1' expr2')) } tcExpr in_expr@(PArrSeq _ seq@(FromThenTo expr1 expr2 expr3)) res_ty - = do { [elt_ty] <- boxySplitTyConApp parrTyCon res_ty + = do { (elt_ty, coi) <- boxySplitPArrTy res_ty ; expr1' <- tcPolyExpr expr1 elt_ty ; expr2' <- tcPolyExpr expr2 elt_ty ; expr3' <- tcPolyExpr expr3 elt_ty ; eft <- newMethodFromName (PArrSeqOrigin seq) elt_ty enumFromThenToPName - ; return (PArrSeq (HsVar eft) (FromThenTo expr1' expr2' expr3')) } + ; return $ mkHsWrapCoI coi + (PArrSeq (HsVar eft) (FromThenTo expr1' expr2' expr3')) } tcExpr (PArrSeq _ _) _ = panic "TcExpr.tcMonoExpr: Infinite parallel array!" @@ -663,6 +686,7 @@ tcIdApp fun_name n_args arg_checker res_ty -- tcFun work nicely for OpApp and Sections too ; fun' <- instFun orig fun res_subst tv_theta_prs ; co_fn' <- wrapFunResCoercion (substTys res_subst fun_arg_tys) co_fn + ; traceTc (text "tcIdApp: " <+> ppr (mkHsWrap co_fn' fun') <+> ppr tv_theta_prs <+> ppr co_fn' <+> ppr fun') ; return (mkHsWrap co_fn' fun', args') } \end{code} @@ -706,6 +730,7 @@ tcId orig fun_name res_ty -- And pack up the results ; fun' <- instFun orig fun res_subst tv_theta_prs + ; traceTc (text "tcId yields" <+> ppr (mkHsWrap co_fn fun')) ; return (mkHsWrap co_fn fun') } -- Note [Push result type in] @@ -750,27 +775,32 @@ instFun orig fun subst [] instFun orig fun subst tv_theta_prs = do { let ty_theta_prs' = map subst_pr tv_theta_prs - + ; traceTc (text "instFun" <+> ppr ty_theta_prs') -- Make two ad-hoc checks ; doStupidChecks fun ty_theta_prs' -- Now do normal instantiation - ; go True fun ty_theta_prs' } + ; result <- go True fun ty_theta_prs' + ; traceTc (text "instFun result" <+> ppr result) + ; return result + } where subst_pr (tvs, theta) = (substTyVars subst tvs, substTheta subst theta) - go _ fun [] = return fun + go _ fun [] = do {traceTc (text "go _ fun [] returns" <+> ppr fun) ; return fun } go True (HsVar fun_id) ((tys,theta) : prs) | want_method_inst theta - = do { meth_id <- newMethodWithGivenTy orig fun_id tys + = do { traceTc (text "go (HsVar fun_id) ((tys,theta) : prs) | want_method_inst theta") + ; meth_id <- newMethodWithGivenTy orig fun_id tys ; go False (HsVar meth_id) prs } -- Go round with 'False' to prevent further use -- of newMethod: see Note [Multiple instantiation] go _ fun ((tys, theta) : prs) = do { co_fn <- instCall orig tys theta + ; traceTc (text "go yields co_fn" <+> ppr co_fn) ; go False (HsWrap co_fn fun) prs } -- See Note [No method sharing] @@ -856,6 +886,7 @@ tcArgs fun args qtvs qtys arg_tys ; qtys' <- mapM refineBox qtys -- Exploit new info ; (qtys'', args') <- go (n+1) qtys' args arg_tys ; return (qtys'', arg':args') } + go n qtys args arg_tys = panic "tcArgs" tcArg :: LHsExpr Name -- The function -> Int -- and arg number (for error messages) @@ -943,8 +974,11 @@ lookupFun orig id_name ATcId { tct_id = id, tct_type = ty, tct_co = mb_co, tct_level = lvl } -> do { thLocalId orig id ty lvl ; case mb_co of - Nothing -> return (HsVar id, ty) -- Wobbly, or no free vars - Just co -> return (mkHsWrap co (HsVar id), ty) } + Unrefineable -> return (HsVar id, ty) + Rigid co -> return (mkHsWrap co (HsVar id), ty) + Wobbly -> traceTc (text "lookupFun" <+> ppr id) >> return (HsVar id, ty) -- Wobbly, or no free vars + WobblyInvisible -> failWithTc (ppr id_name <+> ptext SLIT(" not in scope because it has a wobbly type (solution: add a type annotation)")) + } other -> failWithTc (ppr other <+> ptext SLIT("used where a value identifer was expected")) } @@ -967,7 +1001,7 @@ thLocalId orig id id_ty th_bind_lvl -------------------------------------- thBrackId orig id ps_var lie_var - | isExternalName id_name + | thTopLevelId id = -- Top-level identifiers in this module, -- (which have External Names) -- are just like the imported case: @@ -978,7 +1012,7 @@ thBrackId orig id ps_var lie_var -- But we do need to put f into the keep-alive -- set, because after desugaring the code will -- only mention f's *name*, not f itself. - do { keepAliveTc id_name; return id } + do { keepAliveTc id; return id } | otherwise = -- Nested identifiers, such as 'x' in @@ -1010,11 +1044,9 @@ thBrackId orig id ps_var lie_var -- Update the pending splices ; ps <- readMutVar ps_var - ; writeMutVar ps_var ((id_name, nlHsApp (nlHsVar lift) (nlHsVar id)) : ps) + ; writeMutVar ps_var ((idName id, nlHsApp (nlHsVar lift) (nlHsVar id)) : ps) ; return id } } - where - id_name = idName id #endif /* GHCI */ \end{code} @@ -1049,18 +1081,18 @@ tcRecordBinds -> HsRecordBinds Name -> TcM (HsRecordBinds TcId) -tcRecordBinds data_con arg_tys (HsRecordBinds rbinds) +tcRecordBinds data_con arg_tys (HsRecFields rbinds dd) = do { mb_binds <- mappM do_bind rbinds - ; return (HsRecordBinds (catMaybes mb_binds)) } + ; return (HsRecFields (catMaybes mb_binds) dd) } where flds_w_tys = zipEqual "tcRecordBinds" (dataConFieldLabels data_con) arg_tys - do_bind (L loc field_lbl, rhs) + do_bind fld@(HsRecField { hsRecFieldId = L loc field_lbl, hsRecFieldArg = rhs }) | Just field_ty <- assocMaybe flds_w_tys field_lbl = addErrCtxt (fieldCtxt field_lbl) $ do { rhs' <- tcPolyExprNC rhs field_ty ; sel_id <- tcLookupField field_lbl ; ASSERT( isRecordSelector sel_id ) - return (Just (L loc sel_id, rhs')) } + return (Just (fld { hsRecFieldId = L loc sel_id, hsRecFieldArg = rhs' })) } | otherwise = do { addErrTc (badFieldCon data_con field_lbl) ; return Nothing } @@ -1095,7 +1127,7 @@ checkMissingFields data_con rbinds not (fl `elem` field_names_used) ] - field_names_used = recBindFields rbinds + field_names_used = hsRecFields rbinds field_labels = dataConFieldLabels data_con field_info = zipEqual "missingFields" @@ -1131,12 +1163,13 @@ predCtxt expr = hang (ptext SLIT("In the predicate expression:")) 4 (ppr expr) nonVanillaUpd tycon - = vcat [ptext SLIT("Record update for the non-Haskell-98 data type") <+> quotes (ppr tycon) + = vcat [ptext SLIT("Record update for the non-Haskell-98 data type") + <+> quotes (pprSourceTyCon tycon) <+> ptext SLIT("is not (yet) supported"), ptext SLIT("Use pattern-matching instead")] badFieldsUpd rbinds = hang (ptext SLIT("No constructor has all these fields:")) - 4 (pprQuotedList (recBindFields rbinds)) + 4 (pprQuotedList (hsRecFields rbinds)) naughtyRecordSel sel_id = ptext SLIT("Cannot use record selector") <+> quotes (ppr sel_id) <+> @@ -1162,8 +1195,7 @@ missingFields con fields = ptext SLIT("Fields of") <+> quotes (ppr con) <+> ptext SLIT("not initialised:") <+> pprWithCommas ppr fields -callCtxt fun args - = ptext SLIT("In the call") <+> parens (ppr (foldl mkHsApp fun args)) +-- callCtxt fun args = ptext SLIT("In the call") <+> parens (ppr (foldl mkHsApp fun args)) #ifdef GHCI polySpliceErr :: Id -> SDoc