X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcExpr.lhs;h=7aecdaaf81061d0ed2b46ca7a47a652039bbfbd0;hb=3ca33229d4b9c1ed2829318631e73e748154f3ff;hp=84fc1d92c9946d55a85b8665a154299c1a8887d0;hpb=625f0ad83a38d5dc2c3a5fd69f2f4d0ed9283dc2;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcExpr.lhs b/ghc/compiler/typecheck/TcExpr.lhs index 84fc1d9..7aecdaa 100644 --- a/ghc/compiler/typecheck/TcExpr.lhs +++ b/ghc/compiler/typecheck/TcExpr.lhs @@ -4,25 +4,29 @@ \section[TcExpr]{Typecheck an expression} \begin{code} -module TcExpr ( tcExpr, tcPolyExpr, tcId ) where +module TcExpr ( tcApp, tcExpr, tcPolyExpr, tcId ) where #include "HsVersions.h" import HsSyn ( HsExpr(..), HsLit(..), ArithSeqInfo(..), HsBinds(..), Stmt(..), StmtCtxt(..), - failureFreePat + mkMonoBind, nullMonoBinds ) import RnHsSyn ( RenamedHsExpr, RenamedRecordBinds ) import TcHsSyn ( TcExpr, TcRecordBinds, - mkHsTyApp + mkHsTyApp, mkHsLet, maybeBoxedPrimType ) import TcMonad import BasicTypes ( RecFlag(..) ) import Inst ( Inst, InstOrigin(..), OverloadedLit(..), - LIE, emptyLIE, unitLIE, plusLIE, plusLIEs, newOverloadedLit, - newMethod, newMethodWithGivenTy, newDicts, instToId ) + LIE, emptyLIE, unitLIE, consLIE, plusLIE, plusLIEs, + lieToList, listToLIE, tyVarsOfLIE, zonkLIE, + newOverloadedLit, newMethod, newIPDict, + instOverloadedFun, newDicts, newClassDicts, + partitionLIEbyMeth, getIPsOfLIE, instToId, ipToId + ) import TcBinds ( tcBindsAndThen ) import TcEnv ( tcInstId, tcLookupValue, tcLookupClassByKey, @@ -33,31 +37,36 @@ import TcEnv ( tcInstId, import TcMatches ( tcMatchesCase, tcMatchLambda, tcStmts ) import TcMonoType ( tcHsType, checkSigTyVars, sigCtxt ) import TcPat ( badFieldCon ) -import TcSimplify ( tcSimplifyAndCheck ) +import TcSimplify ( tcSimplify, tcSimplifyAndCheck ) import TcType ( TcType, TcTauType, tcInstTyVars, tcInstTcType, tcSplitRhoTy, newTyVarTy, newTyVarTy_OpenKind, zonkTcType ) import Class ( Class ) -import FieldLabel ( FieldLabel, fieldLabelName, fieldLabelType ) +import FieldLabel ( FieldLabel, fieldLabelName, fieldLabelType + ) import Id ( idType, recordSelectorFieldLabel, isRecordSelector, - Id + Id, mkVanillaId + ) +import DataCon ( dataConFieldLabels, dataConSig, dataConId, + dataConStrictMarks, StrictnessMark(..) ) -import DataCon ( dataConFieldLabels, dataConSig, dataConId ) -import Name ( Name ) +import Name ( Name, getName ) import Type ( mkFunTy, mkAppTy, mkTyVarTy, mkTyVarTys, - splitFunTy_maybe, splitFunTys, + ipName_maybe, + splitFunTy_maybe, splitFunTys, isNotUsgTy, mkTyConApp, splitForAllTys, splitRhoTy, isTauTy, tyVarsOfType, tyVarsOfTypes, isForAllTy, splitAlgTyConApp, splitAlgTyConApp_maybe, boxedTypeKind, mkArrowKind, - substTopTheta, tidyOpenType + tidyOpenType ) -import VarEnv ( zipVarEnv ) -import VarSet ( elemVarSet, mkVarSet ) +import Subst ( mkTopTyVarSubst, substClasses ) +import UsageSPUtils ( unannotTy ) +import VarSet ( emptyVarSet, unionVarSet, elemVarSet, mkVarSet ) import TyCon ( tyConDataCons ) import TysPrim ( intPrimTy, charPrimTy, doublePrimTy, floatPrimTy, addrPrimTy @@ -69,12 +78,14 @@ import TcUnify ( unifyTauTy, unifyFunTy, unifyListTy, unifyTupleTy, import Unique ( cCallableClassKey, cReturnableClassKey, enumFromClassOpKey, enumFromThenClassOpKey, enumFromToClassOpKey, enumFromThenToClassOpKey, - thenMClassOpKey, zeroClassOpKey, returnMClassOpKey + thenMClassOpKey, failMClassOpKey, returnMClassOpKey ) import Outputable -import Maybes ( maybeToBool ) +import Maybes ( maybeToBool, mapMaybe ) import ListSetOps ( minusList ) import Util +import CmdLineOpts ( opt_WarnMissingFields ) + \end{code} %************************************************************************ @@ -143,7 +154,7 @@ tcPolyExpr arg expected_arg_ty newDicts SignatureOrigin sig_theta `thenNF_Tc` \ (sig_dicts, dict_ids) -> -- ToDo: better origin tcSimplifyAndCheck - (text "tcPolyExpr") + (text "the type signature of an expression") (mkVarSet zonked_sig_tyvars) sig_dicts lie_arg `thenTc` \ (free_insts, inst_binds) -> @@ -153,13 +164,14 @@ tcPolyExpr arg expected_arg_ty -- a couple of new names which seems worse. generalised_arg = TyLam zonked_sig_tyvars $ DictLam dict_ids $ - HsLet (MonoBind inst_binds [] Recursive) + mkHsLet inst_binds $ arg' in returnTc ( generalised_arg, free_insts, arg', sig_tau, lie_arg ) where - sig_msg ty = ptext SLIT("In an expression with expected type:") <+> ppr ty + sig_msg ty = sep [ptext SLIT("In an expression with expected type:"), + nest 4 (ppr ty)] \end{code} %************************************************************************ @@ -170,7 +182,7 @@ tcPolyExpr arg expected_arg_ty \begin{code} tcMonoExpr :: RenamedHsExpr -- Expession to type check - -> TcTauType -- Expected type (could be a type variable) + -> TcTauType -- Expected type (could be a type variable) -> TcM s (TcExpr, LIE) tcMonoExpr (HsVar name) res_ty @@ -186,6 +198,15 @@ tcMonoExpr (HsVar name) res_ty returnTc (expr', lie) \end{code} +\begin{code} +tcMonoExpr (HsIPVar name) res_ty + -- ZZ What's the `id' used for here... + = let id = mkVanillaId name res_ty in + tcGetInstLoc (OccurrenceOf id) `thenNF_Tc` \ loc -> + newIPDict name res_ty loc `thenNF_Tc` \ ip -> + returnNF_Tc (HsIPVar (instToId ip), unitLIE ip) +\end{code} + %************************************************************************ %* * \subsection{Literals} @@ -210,8 +231,8 @@ tcMonoExpr (HsLit (HsFrac f)) res_ty tcMonoExpr (HsLit lit@(HsLitLit s)) res_ty = tcLookupClassByKey cCallableClassKey `thenNF_Tc` \ cCallableClass -> - newDicts (LitLitOrigin (_UNPK_ s)) - [(cCallableClass, [res_ty])] `thenNF_Tc` \ (dicts, _) -> + newClassDicts (LitLitOrigin (_UNPK_ s)) + [(cCallableClass,[res_ty])] `thenNF_Tc` \ (dicts, _) -> returnTc (HsLitOut lit res_ty, dicts) \end{code} @@ -340,16 +361,20 @@ tcMonoExpr (CCall lbl args may_gc is_asm ignored_fake_result_ty) res_ty tcLookupTyCon ioTyCon_NAME `thenNF_Tc` \ ioTyCon -> let new_arg_dict (arg, arg_ty) - = newDicts (CCallOrigin (_UNPK_ lbl) (Just arg)) - [(cCallableClass, [arg_ty])] `thenNF_Tc` \ (arg_dicts, _) -> + = newClassDicts (CCallOrigin (_UNPK_ lbl) (Just arg)) + [(cCallableClass, [arg_ty])] `thenNF_Tc` \ (arg_dicts, _) -> returnNF_Tc arg_dicts -- Actually a singleton bag result_origin = CCallOrigin (_UNPK_ lbl) Nothing {- Not an arg -} in -- Arguments - mapNF_Tc (\ _ -> newTyVarTy_OpenKind) [1..(length args)] `thenNF_Tc` \ arg_tys -> - tcMonoExprs args arg_tys `thenTc` \ (args', args_lie) -> + let n_args = length args + tv_idxs | n_args == 0 = [] + | otherwise = [1..n_args] + in + mapNF_Tc (\ _ -> newTyVarTy_OpenKind) tv_idxs `thenNF_Tc` \ arg_tys -> + tcMonoExprs args arg_tys `thenTc` \ (args', args_lie) -> -- The argument types can be unboxed or boxed; the result -- type must, however, be boxed since it's an argument to the IO @@ -364,8 +389,7 @@ tcMonoExpr (CCall lbl args may_gc is_asm ignored_fake_result_ty) res_ty -- Construct the extra insts, which encode the -- constraints on the argument and result types. mapNF_Tc new_arg_dict (zipEqual "tcMonoExpr:CCall" args arg_tys) `thenNF_Tc` \ ccarg_dicts_s -> - newDicts result_origin [(cReturnableClass, [result_ty])] `thenNF_Tc` \ (ccres_dict, _) -> - + newClassDicts result_origin [(cReturnableClass, [result_ty])] `thenNF_Tc` \ (ccres_dict, _) -> returnTc (HsApp (HsVar (dataConId ioDataCon) `TyApp` [result_ty]) (CCall lbl args' may_gc is_asm result_ty), -- do the wrapping in the newtype constructor here @@ -373,9 +397,9 @@ tcMonoExpr (CCall lbl args may_gc is_asm ignored_fake_result_ty) res_ty \end{code} \begin{code} -tcMonoExpr (HsSCC label expr) res_ty +tcMonoExpr (HsSCC lbl expr) res_ty = tcMonoExpr expr res_ty `thenTc` \ (expr', lie) -> - returnTc (HsSCC label expr', lie) + returnTc (HsSCC lbl expr', lie) tcMonoExpr (HsLet binds expr) res_ty = tcBindsAndThen @@ -386,7 +410,7 @@ tcMonoExpr (HsLet binds expr) res_ty where tc_expr = tcMonoExpr expr res_ty `thenTc` \ (expr', lie) -> returnTc (expr', lie) - combiner is_rec bind expr = HsLet (MonoBind bind [] is_rec) expr + combiner is_rec bind expr = HsLet (mkMonoBind bind [] is_rec) expr tcMonoExpr in_expr@(HsCase scrut matches src_loc) res_ty = tcAddSrcLoc src_loc $ @@ -450,8 +474,9 @@ tcMonoExpr (ExplicitTuple exprs boxed) res_ty `thenTc` \ (exprs', lies) -> returnTc (ExplicitTuple exprs' boxed, plusLIEs lies) -tcMonoExpr (RecordCon con_name rbinds) res_ty - = tcId con_name `thenNF_Tc` \ (con_expr, con_lie, con_tau) -> +tcMonoExpr expr@(RecordCon con_name rbinds) res_ty + = tcAddErrCtxt (recordConCtxt expr) $ + tcId con_name `thenNF_Tc` \ (con_expr, con_lie, con_tau) -> let (_, record_ty) = splitFunTys con_tau in @@ -471,10 +496,22 @@ tcMonoExpr (RecordCon con_name rbinds) res_ty -- Typecheck the record bindings tcRecordBinds record_ty rbinds `thenTc` \ (rbinds', rbinds_lie) -> + + let + missing_s_fields = missingStrictFields rbinds data_con + in + checkTcM (null missing_s_fields) + (mapNF_Tc (addErrTc . missingStrictFieldCon con_name) missing_s_fields `thenNF_Tc_` + returnNF_Tc ()) `thenNF_Tc_` + let + missing_fields = missingFields rbinds data_con + in + checkTcM (not (opt_WarnMissingFields && not (null missing_fields))) + (mapNF_Tc ((warnTc True) . missingFieldCon con_name) missing_fields `thenNF_Tc_` + returnNF_Tc ()) `thenNF_Tc_` returnTc (RecordConOut data_con con_expr rbinds', con_lie `plusLIE` rbinds_lie) - -- The main complication with RecordUpd is that we need to explicitly -- handle the *non-updated* fields. Consider: -- @@ -501,22 +538,34 @@ tcMonoExpr (RecordCon con_name rbinds) res_ty -- -- All this is done in STEP 4 below. -tcMonoExpr (RecordUpd record_expr rbinds) res_ty - = tcAddErrCtxt recordUpdCtxt $ +tcMonoExpr expr@(RecordUpd record_expr rbinds) res_ty + = tcAddErrCtxt (recordUpdCtxt expr) $ - -- STEP 1 - -- Figure out the tycon and data cons from the first field name + -- STEP 0 + -- Check that the field names are really field names ASSERT( not (null rbinds) ) let - ((first_field_name, _, _) : rest) = rbinds + field_names = [field_name | (field_name, _, _) <- rbinds] in - tcLookupValueMaybe first_field_name `thenNF_Tc` \ maybe_sel_id -> - (case maybe_sel_id of - Just sel_id | isRecordSelector sel_id -> returnTc sel_id - other -> failWithTc (notSelector first_field_name) - ) `thenTc` \ sel_id -> + mapNF_Tc tcLookupValueMaybe field_names `thenNF_Tc` \ maybe_sel_ids -> let - (_, tau) = splitForAllTys (idType sel_id) + bad_guys = [field_name | (field_name, maybe_sel_id) <- field_names `zip` maybe_sel_ids, + case maybe_sel_id of + Nothing -> True + Just sel_id -> not (isRecordSelector sel_id) + ] + in + mapNF_Tc (addErrTc . notSelector) bad_guys `thenTc_` + if not (null bad_guys) then + failTc + else + + -- STEP 1 + -- Figure out the tycon and data cons from the first field name + let + (Just sel_id : _) = maybe_sel_ids + (_, tau) = ASSERT( isNotUsgTy (idType sel_id) ) + splitForAllTys (idType sel_id) Just (data_ty, _) = splitFunTy_maybe tau -- Must succeed since sel_id is a selector (tycon, _, data_cons) = splitAlgTyConApp data_ty (con_tyvars, theta, _, _, _, _) = dataConSig (head data_cons) @@ -524,9 +573,11 @@ tcMonoExpr (RecordUpd record_expr rbinds) res_ty tcInstTyVars con_tyvars `thenNF_Tc` \ (_, result_inst_tys, _) -> -- STEP 2 - -- Check for bad fields + -- Check that at least one constructor has all the named fields + -- i.e. has an empty set of bad fields returned by badFields checkTc (any (null . badFields rbinds) data_cons) (badFieldsUpd rbinds) `thenTc_` + -- STEP 3 -- Typecheck the update bindings. -- (Do this after checking for bad fields in case there's a field that @@ -579,10 +630,10 @@ tcMonoExpr (RecordUpd record_expr rbinds) res_ty -- union the ones that could participate in the update. let (tyvars, theta, _, _, _, _) = dataConSig (head data_cons) - inst_env = zipVarEnv tyvars result_inst_tys - theta' = substTopTheta inst_env theta + inst_env = mkTopTyVarSubst tyvars result_inst_tys + theta' = substClasses inst_env theta in - newDicts RecordUpdOrigin theta' `thenNF_Tc` \ (con_lie, dicts) -> + newClassDicts RecordUpdOrigin theta' `thenNF_Tc` \ (con_lie, dicts) -> -- Phew! returnTc (RecordUpdOut record_expr' result_record_ty dicts rbinds', @@ -674,6 +725,51 @@ tcMonoExpr in_expr@(ExprWithTySig expr poly_ty) res_ty returnTc (expr, lie) \end{code} +Implicit Parameter bindings. + +\begin{code} +tcMonoExpr (HsWith expr binds) res_ty + = tcMonoExpr expr res_ty `thenTc` \ (expr', lie) -> + tcIPBinds binds `thenTc` \ (binds', types, lie2) -> + partitionLIEbyMeth isBound lie `thenTc` \ (ips, lie') -> + zonkLIE ips `thenTc` \ ips' -> + tcSimplify (text "With!") (tyVarsOfLIE ips') ips' `thenTc` \ res@(_, dict_binds, _) -> + let expr'' = if nullMonoBinds dict_binds + then expr' + else HsLet (MonoBind dict_binds [] NonRecursive) expr' in + tcCheckIPBinds binds' types ips' `thenTc_` + returnTc (HsWith expr'' binds', lie' `plusLIE` lie2) + where isBound p + = case ipName_maybe p of + Just n -> n `elem` names + Nothing -> False + names = map fst binds + +tcIPBinds ((name, expr) : binds) + = newTyVarTy_OpenKind `thenTc` \ ty -> + tcGetSrcLoc `thenTc` \ loc -> + let id = ipToId name ty loc in + tcMonoExpr expr ty `thenTc` \ (expr', lie) -> + zonkTcType ty `thenTc` \ ty' -> + tcIPBinds binds `thenTc` \ (binds', types, lie2) -> + returnTc ((id, expr') : binds', ty : types, lie `plusLIE` lie2) +tcIPBinds [] = returnTc ([], [], emptyLIE) + +tcCheckIPBinds binds types ips + = foldrTc tcCheckIPBind (getIPsOfLIE ips) (zip binds types) + +-- ZZ how do we use the loc? +tcCheckIPBind bt@((v, _), t1) ((n, t2) : ips) | getName v == n + = unifyTauTy t1 t2 `thenTc_` + tcCheckIPBind bt ips `thenTc` \ ips' -> + returnTc ips' +tcCheckIPBind bt (ip : ips) + = tcCheckIPBind bt ips `thenTc` \ ips' -> + returnTc (ip : ips') +tcCheckIPBind bt [] + = returnTc [] +\end{code} + Typecheck expression which in most cases will be an Id. \begin{code} @@ -698,9 +794,9 @@ tcExpr_id id_expr \begin{code} -tcApp :: RenamedHsExpr -> [RenamedHsExpr] -- Function and args - -> TcType -- Expected result type of application - -> TcM s (TcExpr, [TcExpr], -- Translated fun and args +tcApp :: RenamedHsExpr -> [RenamedHsExpr] -- Function and args + -> TcType -- Expected result type of application + -> TcM s (TcExpr, [TcExpr], -- Translated fun and args LIE) tcApp fun args res_ty @@ -780,6 +876,12 @@ tcArg the_fun (arg, expected_arg_ty, arg_no) %* * %************************************************************************ +Between the renamer and the first invocation of the UsageSP inference, +identifiers read from interface files will have usage information in +their types, whereas other identifiers will not. The unannotTy here +in @tcId@ prevents this information from pointlessly propagating +further prior to the first usage inference. + \begin{code} tcId :: Name -> NF_TcM s (TcExpr, LIE, TcType) @@ -788,11 +890,11 @@ tcId name tcLookupValueMaybe name `thenNF_Tc` \ maybe_local -> case maybe_local of - Just tc_id -> instantiate_it tc_id (idType tc_id) + Just tc_id -> instantiate_it (OccurrenceOf tc_id) (HsVar tc_id) (unannotTy (idType tc_id)) Nothing -> tcLookupValue name `thenNF_Tc` \ id -> tcInstId id `thenNF_Tc` \ (tyvars, theta, tau) -> - instantiate_it2 id tyvars theta tau + instantiate_it2 (OccurrenceOf id) (HsVar id) tyvars theta tau where -- The instantiate_it loop runs round instantiating the Id. @@ -801,23 +903,22 @@ tcId name -- f:: forall a. Eq a => forall b. Baz b => tau -- We want to instantiate this to -- f2::tau {f2 = f1 b (Baz b), f1 = f a (Eq a)} - instantiate_it tc_id_occ ty + instantiate_it orig fun ty = tcInstTcType ty `thenNF_Tc` \ (tyvars, rho) -> tcSplitRhoTy rho `thenNF_Tc` \ (theta, tau) -> - instantiate_it2 tc_id_occ tyvars theta tau + instantiate_it2 orig fun tyvars theta tau - instantiate_it2 tc_id_occ tyvars theta tau + instantiate_it2 orig fun tyvars theta tau = if null theta then -- Is it overloaded? - returnNF_Tc (mkHsTyApp (HsVar tc_id_occ) arg_tys, emptyLIE, tau) + returnNF_Tc (mkHsTyApp fun arg_tys, emptyLIE, tau) else -- Yes, it's overloaded - newMethodWithGivenTy (OccurrenceOf tc_id_occ) - tc_id_occ arg_tys theta tau `thenNF_Tc` \ inst -> - instantiate_it (instToId inst) tau `thenNF_Tc` \ (expr, lie2, final_tau) -> - returnNF_Tc (expr, unitLIE inst `plusLIE` lie2, final_tau) + instOverloadedFun orig fun arg_tys theta tau `thenNF_Tc` \ (fun', lie1) -> + instantiate_it orig fun' tau `thenNF_Tc` \ (expr, lie2, final_tau) -> + returnNF_Tc (expr, lie1 `plusLIE` lie2, final_tau) where - arg_tys = mkTyVarTys tyvars + arg_tys = mkTyVarTys tyvars \end{code} %************************************************************************ @@ -837,7 +938,14 @@ tcDoStmts do_or_lc stmts src_loc res_ty newTyVarTy boxedTypeKind `thenNF_Tc` \ elt_ty -> unifyTauTy res_ty (mkAppTy m elt_ty) `thenTc_` - tcStmts do_or_lc (mkAppTy m) stmts elt_ty `thenTc` \ (stmts', stmts_lie) -> + -- If it's a comprehension we're dealing with, + -- force it to be a list comprehension. + -- (as of Haskell 98, monad comprehensions are no more.) + (case do_or_lc of + ListComp -> unifyListTy res_ty `thenTc_` returnTc () + _ -> returnTc ()) `thenTc_` + + tcStmts do_or_lc (mkAppTy m) stmts elt_ty `thenTc` \ (stmts', stmts_lie) -> -- Build the then and zero methods in case we need them -- It's important that "then" and "return" appear just once in the final LIE, @@ -849,20 +957,14 @@ tcDoStmts do_or_lc stmts src_loc res_ty -- tcLookupValueByKey returnMClassOpKey `thenNF_Tc` \ return_sel_id -> tcLookupValueByKey thenMClassOpKey `thenNF_Tc` \ then_sel_id -> - tcLookupValueByKey zeroClassOpKey `thenNF_Tc` \ zero_sel_id -> + tcLookupValueByKey failMClassOpKey `thenNF_Tc` \ fail_sel_id -> newMethod DoOrigin return_sel_id [m] `thenNF_Tc` \ (return_lie, return_id) -> newMethod DoOrigin then_sel_id [m] `thenNF_Tc` \ (then_lie, then_id) -> - newMethod DoOrigin zero_sel_id [m] `thenNF_Tc` \ (zero_lie, zero_id) -> + newMethod DoOrigin fail_sel_id [m] `thenNF_Tc` \ (fail_lie, fail_id) -> let - monad_lie = then_lie `plusLIE` return_lie `plusLIE` perhaps_zero_lie - perhaps_zero_lie | all failure_free stmts' = emptyLIE - | otherwise = zero_lie - - failure_free (BindStmt pat _ _) = failureFreePat pat - failure_free (GuardStmt _ _) = False - failure_free other_stmt = True + monad_lie = then_lie `plusLIE` return_lie `plusLIE` fail_lie in - returnTc (HsDoOut do_or_lc stmts' return_id then_id zero_id res_ty src_loc, + returnTc (HsDoOut do_or_lc stmts' return_id then_id fail_id res_ty src_loc, stmts_lie `plusLIE` monad_lie) \end{code} @@ -931,6 +1033,36 @@ badFields rbinds data_con ] where field_names = map fieldLabelName (dataConFieldLabels data_con) + +missingStrictFields rbinds data_con + = [ fn | fn <- strict_field_names, + not (fn `elem` field_names_used) + ] + where + field_names_used = [ field_name | (field_name, _, _) <- rbinds ] + strict_field_names = mapMaybe isStrict field_info + + isStrict (fl, MarkedStrict) = Just (fieldLabelName fl) + isStrict _ = Nothing + + field_info = zip (dataConFieldLabels data_con) + (dataConStrictMarks data_con) + +missingFields rbinds data_con + = [ fn | fn <- non_strict_field_names, not (fn `elem` field_names_used) ] + where + field_names_used = [ field_name | (field_name, _, _) <- rbinds ] + + -- missing strict fields have already been flagged as + -- being so, so leave them out here. + non_strict_field_names = mapMaybe isn'tStrict field_info + + isn'tStrict (fl, MarkedStrict) = Nothing + isn'tStrict (fl, _) = Just (fieldLabelName fl) + + field_info = zip (dataConFieldLabels data_con) + (dataConStrictMarks data_con) + \end{code} %************************************************************************ @@ -958,7 +1090,7 @@ Errors and contexts Mini-utils: \begin{code} pp_nest_hang :: String -> SDoc -> SDoc -pp_nest_hang label stuff = nest 2 (hang (text label) 4 stuff) +pp_nest_hang lbl stuff = nest 2 (hang (text lbl) 4 stuff) \end{code} Boring and alphabetical: @@ -1002,7 +1134,7 @@ wrongArgsCtxt too_many_or_few fun args the_app = foldl HsApp fun args -- Used in error messages appCtxt fun args - = ptext SLIT("In the application") <+> (ppr the_app) + = ptext SLIT("In the application") <+> quotes (ppr the_app) where the_app = foldl HsApp fun args -- Used in error messages @@ -1020,8 +1152,28 @@ badFieldsUpd rbinds where fields = [field | (field, _, _) <- rbinds] -recordUpdCtxt = ptext SLIT("In a record update construct") +recordUpdCtxt expr = ptext SLIT("In the record update:") <+> ppr expr +recordConCtxt expr = ptext SLIT("In the record construction:") <+> ppr expr notSelector field = hsep [quotes (ppr field), ptext SLIT("is not a record selector")] + +illegalCcallTyErr isArg ty + = hang (hsep [ptext SLIT("Unacceptable"), arg_or_res, ptext SLIT("type in _ccall_ or _casm_:")]) + 4 (hsep [ppr ty]) + where + arg_or_res + | isArg = ptext SLIT("argument") + | otherwise = ptext SLIT("result") + + +missingStrictFieldCon :: Name -> Name -> SDoc +missingStrictFieldCon con field + = hsep [ptext SLIT("Constructor") <+> quotes (ppr con), + ptext SLIT("does not have the required strict field"), quotes (ppr field)] + +missingFieldCon :: Name -> Name -> SDoc +missingFieldCon con field + = hsep [ptext SLIT("Field") <+> quotes (ppr field), + ptext SLIT("is not initialised")] \end{code}