X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcExpr.lhs;h=7aecdaaf81061d0ed2b46ca7a47a652039bbfbd0;hb=3ca33229d4b9c1ed2829318631e73e748154f3ff;hp=e2599cf32a84db33d0404b1856628385b8e528ea;hpb=69e14f75a4b031e489b7774914e5a176409cea78;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcExpr.lhs b/ghc/compiler/typecheck/TcExpr.lhs index e2599cf..7aecdaa 100644 --- a/ghc/compiler/typecheck/TcExpr.lhs +++ b/ghc/compiler/typecheck/TcExpr.lhs @@ -9,7 +9,8 @@ module TcExpr ( tcApp, tcExpr, tcPolyExpr, tcId ) where #include "HsVersions.h" import HsSyn ( HsExpr(..), HsLit(..), ArithSeqInfo(..), - HsBinds(..), Stmt(..), StmtCtxt(..) + HsBinds(..), Stmt(..), StmtCtxt(..), + mkMonoBind, nullMonoBinds ) import RnHsSyn ( RenamedHsExpr, RenamedRecordBinds ) import TcHsSyn ( TcExpr, TcRecordBinds, @@ -20,8 +21,12 @@ import TcMonad import BasicTypes ( RecFlag(..) ) import Inst ( Inst, InstOrigin(..), OverloadedLit(..), - LIE, emptyLIE, unitLIE, plusLIE, plusLIEs, newOverloadedLit, - newMethod, instOverloadedFun, 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, @@ -32,21 +37,25 @@ 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 ) -import Name ( Name ) +import DataCon ( dataConFieldLabels, dataConSig, dataConId, + dataConStrictMarks, StrictnessMark(..) + ) +import Name ( Name, getName ) import Type ( mkFunTy, mkAppTy, mkTyVarTy, mkTyVarTys, + ipName_maybe, splitFunTy_maybe, splitFunTys, isNotUsgTy, mkTyConApp, splitForAllTys, splitRhoTy, @@ -55,9 +64,9 @@ import Type ( mkFunTy, mkAppTy, mkTyVarTy, mkTyVarTys, boxedTypeKind, mkArrowKind, tidyOpenType ) -import Subst ( mkTopTyVarSubst, substTheta ) +import Subst ( mkTopTyVarSubst, substClasses ) import UsageSPUtils ( unannotTy ) -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) -> @@ -159,7 +170,8 @@ tcPolyExpr arg expected_arg_ty 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,8 +361,8 @@ 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 -} @@ -368,7 +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 @@ -376,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 @@ -389,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 $ @@ -453,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 @@ -474,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: -- @@ -504,8 +538,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 @@ -597,9 +631,9 @@ tcMonoExpr (RecordUpd record_expr rbinds) res_ty let (tyvars, theta, _, _, _, _) = dataConSig (head data_cons) inst_env = mkTopTyVarSubst tyvars result_inst_tys - theta' = substTheta inst_env theta + 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', @@ -691,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} @@ -954,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} %************************************************************************ @@ -981,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: @@ -1043,7 +1152,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 +1167,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}