X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcExpr.lhs;h=f622d1cb266eabeef6e458b7420a7e259dcc99ff;hb=6c872fff42025a842e8500ddbb13fdcca60eaf75;hp=65af1e1311984a85f72ee25595c41c3e61e7b1c6;hpb=d133b73a4d4717892ced072d05e039a54ede0ceb;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcExpr.lhs b/ghc/compiler/typecheck/TcExpr.lhs index 65af1e1..f622d1c 100644 --- a/ghc/compiler/typecheck/TcExpr.lhs +++ b/ghc/compiler/typecheck/TcExpr.lhs @@ -4,24 +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(..) + HsBinds(..), MonoBinds(..), Stmt(..), StmtCtxt(..), + mkMonoBind, nullMonoBinds ) import RnHsSyn ( RenamedHsExpr, RenamedRecordBinds ) -import TcHsSyn ( TcExpr, TcRecordBinds, - mkHsTyApp, maybeBoxedPrimType +import TcHsSyn ( TcExpr, TcRecordBinds, mkHsConApp, + 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, + newOverloadedLit, newMethod, newIPDict, + instOverloadedFun, newDicts, newClassDicts, + getIPsOfLIE, instToId, ipToId + ) import TcBinds ( tcBindsAndThen ) import TcEnv ( tcInstId, tcLookupValue, tcLookupClassByKey, @@ -30,34 +35,38 @@ import TcEnv ( tcInstId, tcLookupTyCon, tcLookupDataCon ) import TcMatches ( tcMatchesCase, tcMatchLambda, tcStmts ) -import TcMonoType ( tcHsType, checkSigTyVars, sigCtxt ) +import TcMonoType ( tcHsSigType, checkSigTyVars, sigCtxt ) import TcPat ( badFieldCon ) -import TcSimplify ( tcSimplifyAndCheck ) +import TcSimplify ( tcSimplify, tcSimplifyAndCheck, partitionPredsOfLIE ) 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 ) -import Name ( Name ) +import DataCon ( dataConFieldLabels, dataConSig, + dataConStrictMarks, StrictnessMark(..) + ) +import Name ( Name, getName ) import Type ( mkFunTy, mkAppTy, mkTyVarTy, mkTyVarTys, + ipName_maybe, splitFunTy_maybe, splitFunTys, isNotUsgTy, mkTyConApp, splitForAllTys, splitRhoTy, isTauTy, tyVarsOfType, tyVarsOfTypes, isForAllTy, splitAlgTyConApp, splitAlgTyConApp_maybe, boxedTypeKind, mkArrowKind, - substTopTheta, tidyOpenType + tidyOpenType ) +import Subst ( mkTopTyVarSubst, substClasses ) import UsageSPUtils ( unannotTy ) -import VarEnv ( zipVarEnv ) -import VarSet ( elemVarSet, mkVarSet ) +import VarSet ( emptyVarSet, unionVarSet, elemVarSet, mkVarSet ) import TyCon ( tyConDataCons ) import TysPrim ( intPrimTy, charPrimTy, doublePrimTy, floatPrimTy, addrPrimTy @@ -72,9 +81,11 @@ import Unique ( cCallableClassKey, cReturnableClassKey, 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} @@ -333,15 +354,15 @@ arg/result types); unify them with the args/result; and store them for later use. \begin{code} -tcMonoExpr (CCall lbl args may_gc is_asm ignored_fake_result_ty) res_ty +tcMonoExpr (HsCCall lbl args may_gc is_asm ignored_fake_result_ty) res_ty = -- Get the callable and returnable classes. tcLookupClassByKey cCallableClassKey `thenNF_Tc` \ cCallableClass -> tcLookupClassByKey cReturnableClassKey `thenNF_Tc` \ cReturnableClass -> 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 -} @@ -368,17 +389,16 @@ 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, _) -> - returnTc (HsApp (HsVar (dataConId ioDataCon) `TyApp` [result_ty]) - (CCall lbl args' may_gc is_asm result_ty), + newClassDicts result_origin [(cReturnableClass, [result_ty])] `thenNF_Tc` \ (ccres_dict, _) -> + returnTc (mkHsConApp ioDataCon [result_ty] [HsCCall lbl args' may_gc is_asm result_ty], -- do the wrapping in the newtype constructor here foldr plusLIE ccres_dict ccarg_dicts_s `plusLIE` args_lie) \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 @@ -389,7 +409,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 $ @@ -453,16 +473,17 @@ 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 - -- Con is syntactically constrained to be a data constructor ASSERT( maybeToBool (splitAlgTyConApp_maybe record_ty ) ) unifyTauTy res_ty record_ty `thenTc_` -- Check that the record bindings match the constructor + -- con_name is syntactically constrained to be a data constructor tcLookupDataCon con_name `thenTc` \ (data_con, _, _) -> let bad_fields = badFields rbinds data_con @@ -474,10 +495,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: -- @@ -504,8 +537,8 @@ 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 0 -- Check that the field names are really field names @@ -596,10 +629,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', @@ -666,7 +699,7 @@ tcMonoExpr in_expr@(ArithSeqIn seq@(FromThenTo expr1 expr2 expr3)) res_ty \begin{code} tcMonoExpr in_expr@(ExprWithTySig expr poly_ty) res_ty = tcSetErrCtxt (exprSigCtxt in_expr) $ - tcHsType poly_ty `thenTc` \ sig_tc_ty -> + tcHsSigType poly_ty `thenTc` \ sig_tc_ty -> if not (isForAllTy sig_tc_ty) then -- Easy case @@ -691,6 +724,59 @@ 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) -> + partitionPredsOfLIE isBound lie `thenTc` \ (ips, lie', dict_binds) -> + pprTrace "tcMonoExpr With" (ppr (ips, lie', dict_binds)) $ + let expr'' = if nullMonoBinds dict_binds + then expr' + else HsLet (mkMonoBind (revBinds 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 + -- revBinds is used because tcSimplify outputs the bindings + -- out-of-order. it's not a problem elsewhere because these + -- bindings are normally used in a recursive let + -- ZZ probably need to find a better solution + revBinds (b1 `AndMonoBinds` b2) = + (revBinds b2) `AndMonoBinds` (revBinds b1) + revBinds b = b + +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} @@ -715,9 +801,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 @@ -811,11 +897,11 @@ tcId name tcLookupValueMaybe name `thenNF_Tc` \ maybe_local -> case maybe_local of - Just tc_id -> instantiate_it tc_id (unannotTy (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. @@ -824,23 +910,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} %************************************************************************ @@ -859,6 +944,7 @@ tcDoStmts do_or_lc stmts src_loc res_ty newTyVarTy (mkArrowKind boxedTypeKind boxedTypeKind) `thenNF_Tc` \ m -> newTyVarTy boxedTypeKind `thenNF_Tc` \ elt_ty -> unifyTauTy res_ty (mkAppTy m elt_ty) `thenTc_` + -- 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.) @@ -954,6 +1040,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} %************************************************************************ @@ -981,7 +1097,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: @@ -1043,7 +1159,8 @@ 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")] @@ -1057,4 +1174,13 @@ illegalCcallTyErr isArg ty | 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}