X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcInstDcls.lhs;h=a140b9c832e0186c934e487fe98ca7d0670e59b1;hb=ee7aa7a67308ea2e8f3cca59ef7a7193291059a8;hp=e3efa78ecccba6452afbffec3660750ac1a72a7e;hpb=b117679aefcfabd2f8b34a9f495ede8508d7f88d;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcInstDcls.lhs b/ghc/compiler/typecheck/TcInstDcls.lhs index e3efa78..a140b9c 100644 --- a/ghc/compiler/typecheck/TcInstDcls.lhs +++ b/ghc/compiler/typecheck/TcInstDcls.lhs @@ -1,72 +1,65 @@ % -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996 +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % \section[TcInstDecls]{Typechecking instance declarations} \begin{code} -module TcInstDcls ( - tcInstDecls1, - tcInstDecls2 - ) where +module TcInstDcls ( tcInstDecls1, tcInstDecls2 ) where #include "HsVersions.h" import HsSyn ( HsDecl(..), InstDecl(..), - HsBinds(..), MonoBinds(..), GRHSsAndBinds(..), GRHS(..), + HsBinds(..), MonoBinds(..), HsExpr(..), InPat(..), HsLit(..), Sig(..), - unguardedRHS, - collectMonoBinders, andMonoBinds - ) -import HsBinds ( sigsForMe ) -import RnHsSyn ( RenamedHsBinds, RenamedMonoBinds, - RenamedInstDecl, RenamedHsExpr, - RenamedSig, RenamedHsDecl - ) -import TcHsSyn ( TcMonoBinds, TcIdOcc(..), TcIdBndr, - maybeBoxedPrimType, tcIdType + andMonoBindList ) +import RnHsSyn ( RenamedHsBinds, RenamedInstDecl, RenamedHsDecl ) +import TcHsSyn ( TcMonoBinds, mkHsConApp ) -import TcBinds ( tcPragmaSigs ) -import TcClassDcl ( tcMethodBind, badMethodErr ) +import TcBinds ( tcSpecSigs ) +import TcClassDcl ( tcMethodBind, checkFromThisClass ) import TcMonad -import RnMonad ( RnNameSupply ) +import RnMonad ( RnNameSupply, FixityEnv ) import Inst ( Inst, InstOrigin(..), - newDicts, LIE, emptyLIE, plusLIE, plusLIEs ) + newDicts, newClassDicts, + LIE, emptyLIE, plusLIE, plusLIEs ) import TcDeriv ( tcDeriving ) -import TcEnv ( GlobalValueEnv, tcExtendGlobalValEnv, tcAddImportedIdInfo ) -import TcInstUtil ( InstInfo(..), mkInstanceRelatedIds, classDataCon ) -import TcKind ( TcKind, unifyKind ) -import TcMonoType ( tcHsType ) -import TcSimplify ( tcSimplifyAndCheck ) -import TcType ( TcType, TcTyVar, TcTyVarSet, - zonkSigTyVar, tcInstSigType, tcInstTheta +import TcEnv ( ValueEnv, tcExtendGlobalValEnv, tcExtendTyVarEnvForMeths, + tcAddImportedIdInfo, tcInstId ) +import TcInstUtil ( InstInfo(..), classDataCon ) +import TcMonoType ( tcHsTopType ) +import TcSimplify ( tcSimplifyAndCheck ) +import TcType ( TcTyVar, zonkTcTyVarBndr ) import Bag ( emptyBag, unitBag, unionBags, unionManyBags, - foldBag, bagToList, Bag + foldBag, Bag ) -import CmdLineOpts ( opt_GlasgowExts ) +import CmdLineOpts ( opt_GlasgowExts, opt_AllowUndecidableInstances ) import Class ( classBigSig, Class ) -import Id ( isNullaryDataCon, dataConArgTys, replaceIdInfo, idName, idType, Id ) -import Maybes ( maybeToBool, seqMaybe, catMaybes, expectJust ) -import Name ( nameOccName, mkLocalName, - isLocallyDefined, Module, - NamedThing(..) - ) -import PrelVals ( eRROR_ID ) -import PprType ( pprParendType, pprConstraint ) -import SrcLoc ( SrcLoc, noSrcLoc ) -import TyCon ( isSynTyCon, isDataTyCon, tyConDerivings ) -import Type ( Type, ThetaType, isUnpointedType, - splitSigmaTy, isTyVarTy, mkSigmaTy, +import Var ( idName, idType, Id, TyVar ) +import DataCon ( isNullaryDataCon, splitProductType_maybe ) +import Maybes ( maybeToBool, catMaybes, expectJust ) +import MkId ( mkDictFunId ) +import Module ( ModuleName ) +import Name ( isLocallyDefined, NamedThing(..) ) +import NameSet ( emptyNameSet ) +import PrelInfo ( eRROR_ID ) +import PprType ( pprConstraint ) +import SrcLoc ( SrcLoc ) +import TyCon ( isSynTyCon, tyConDerivings ) +import Type ( Type, isUnLiftedType, mkTyVarTys, + splitSigmaTy, isTyVarTy, splitTyConApp_maybe, splitDictTy_maybe, - splitAlgTyConApp_maybe, splitRhoTy, - tyVarsOfTypes, mkTyVarTys, + getClassTys_maybe, splitAlgTyConApp_maybe, + classesToPreds, classesOfPreds, + unUsgTy, tyVarsOfTypes ) -import TyVar ( zipTyVarEnv, mkTyVarSet, tyVarSetToList, TyVar ) +import Subst ( mkTopTyVarSubst, substClasses ) +import VarSet ( mkVarSet, varSetElems ) import TysPrim ( byteArrayPrimTyCon, mutableByteArrayPrimTyCon ) -import TysWiredIn ( stringTy ) -import Unique ( Unique, cCallableClassKey, cReturnableClassKey, Uniquable(..) ) +import TysWiredIn ( stringTy, isFFIArgumentTy, isFFIResultTy ) +import Unique ( Unique, cCallableClassKey, cReturnableClassKey, hasKey, Uniquable(..) ) import Outputable \end{code} @@ -144,17 +137,17 @@ and $dbinds_super$ bind the superclass dictionaries sd1 \ldots sdm. \end{enumerate} \begin{code} -tcInstDecls1 :: GlobalValueEnv -- Contains IdInfo for dfun ids +tcInstDecls1 :: ValueEnv -- Contains IdInfo for dfun ids -> [RenamedHsDecl] - -> Module -- module name for deriving + -> ModuleName -- module name for deriving + -> FixityEnv -> RnNameSupply -- for renaming derivings -> TcM s (Bag InstInfo, - RenamedHsBinds, - SDoc) + RenamedHsBinds) -tcInstDecls1 unf_env decls mod_name rn_name_supply +tcInstDecls1 unf_env decls mod_name fixs rn_name_supply = -- Do the ordinary instance declarations - mapNF_Tc (tcInstDecl1 unf_env mod_name) + mapNF_Tc (tcInstDecl1 unf_env) [inst_decl | InstD inst_decl <- decls] `thenNF_Tc` \ inst_info_bags -> let decl_inst_info = unionManyBags inst_info_bags @@ -162,44 +155,53 @@ tcInstDecls1 unf_env decls mod_name rn_name_supply -- Handle "derived" instances; note that we only do derivings -- for things in this module; we ignore deriving decls from -- interfaces! - tcDeriving mod_name rn_name_supply decl_inst_info - `thenTc` \ (deriv_inst_info, deriv_binds, ddump_deriv) -> + tcDeriving mod_name fixs rn_name_supply decl_inst_info + `thenTc` \ (deriv_inst_info, deriv_binds) -> let full_inst_info = deriv_inst_info `unionBags` decl_inst_info in - returnTc (full_inst_info, deriv_binds, ddump_deriv) + returnTc (full_inst_info, deriv_binds) -tcInstDecl1 :: GlobalValueEnv -> Module -> RenamedInstDecl -> NF_TcM s (Bag InstInfo) +tcInstDecl1 :: ValueEnv -> RenamedInstDecl -> NF_TcM s (Bag InstInfo) -tcInstDecl1 unf_env mod_name (InstDecl poly_ty binds uprags (Just dfun_name) src_loc) +tcInstDecl1 unf_env (InstDecl poly_ty binds uprags dfun_name src_loc) = -- Prime error recovery, set source location recoverNF_Tc (returnNF_Tc emptyBag) $ tcAddSrcLoc src_loc $ -- Type-check all the stuff before the "where" - tcHsType poly_ty `thenTc` \ poly_ty' -> + tcHsTopType poly_ty `thenTc` \ poly_ty' -> let (tyvars, theta, dict_ty) = splitSigmaTy poly_ty' - (clas, inst_tys) = case splitDictTy_maybe dict_ty of - Nothing -> pprPanic "tcInstDecl1" (ppr poly_ty) - Just pair -> pair + constr = classesOfPreds theta + (clas, inst_tys) = case splitDictTy_maybe dict_ty of + Just ct -> ct + Nothing -> pprPanic "tcInstDecl1" (ppr poly_ty) in -- Check for respectable instance type, and context - scrutiniseInstanceHead clas inst_tys `thenNF_Tc_` - mapNF_Tc scrutiniseInstanceConstraint theta `thenNF_Tc_` - - -- Make the dfun id and constant-method ids + -- but only do this for non-imported instance decls. + -- Imported ones should have been checked already, and may indeed + -- contain something illegal in normal Haskell, notably + -- instance CCallable [Char] + (if isLocallyDefined dfun_name then + scrutiniseInstanceHead clas inst_tys `thenNF_Tc_` + mapNF_Tc scrutiniseInstanceConstraint constr + else + returnNF_Tc [] + ) `thenNF_Tc_` + + -- Make the dfun id let - (dfun_id, dfun_theta) = mkInstanceRelatedIds dfun_name - clas tyvars inst_tys theta + dfun_id = mkDictFunId dfun_name clas tyvars inst_tys constr + -- Add info from interface file final_dfun_id = tcAddImportedIdInfo unf_env dfun_id in - returnTc (unitBag (InstInfo clas tyvars inst_tys theta - dfun_theta final_dfun_id + returnTc (unitBag (InstInfo clas tyvars inst_tys constr + final_dfun_id binds src_loc uprags)) \end{code} @@ -212,7 +214,7 @@ tcInstDecl1 unf_env mod_name (InstDecl poly_ty binds uprags (Just dfun_name) src \begin{code} tcInstDecls2 :: Bag InstInfo - -> NF_TcM s (LIE s, TcMonoBinds s) + -> NF_TcM s (LIE, TcMonoBinds) tcInstDecls2 inst_decls = foldBag combine tcInstDecl2 (returnNF_Tc (emptyLIE, EmptyMonoBinds)) inst_decls @@ -291,10 +293,10 @@ is the @dfun_theta@ below. First comes the easy case of a non-local instance decl. \begin{code} -tcInstDecl2 :: InstInfo -> NF_TcM s (LIE s, TcMonoBinds s) +tcInstDecl2 :: InstInfo -> NF_TcM s (LIE, TcMonoBinds) tcInstDecl2 (InstInfo clas inst_tyvars inst_tys - inst_decl_theta dfun_theta + inst_decl_theta dfun_id monobinds locn uprags) | not (isLocallyDefined dfun_id) @@ -317,63 +319,59 @@ tcInstDecl2 (InstInfo clas inst_tyvars inst_tys tcAddSrcLoc locn $ -- Instantiate the instance decl with tc-style type variables - tcInstSigType (idType dfun_id) `thenNF_Tc` \ dfun_ty' -> + tcInstId dfun_id `thenNF_Tc` \ (inst_tyvars', dfun_theta', dict_ty') -> let - (inst_tyvars', - dfun_theta', dict_ty') = splitSigmaTy dfun_ty' - (clas, inst_tys') = expectJust "tcInstDecl2" (splitDictTy_maybe dict_ty') - (class_tyvars, - sc_theta, sc_sel_ids, - op_sel_ids, defm_ids) = classBigSig clas - origin = InstanceDeclOrigin - in - -- Instantiate the theta found in the original instance decl - tcInstTheta (zipTyVarEnv inst_tyvars (mkTyVarTys inst_tyvars')) - inst_decl_theta `thenNF_Tc` \ inst_decl_theta' -> - -- Instantiate the super-class context with the instance types - tcInstTheta (zipTyVarEnv class_tyvars inst_tys') sc_theta `thenNF_Tc` \ sc_theta' -> + (class_tyvars, sc_theta, _, op_items) = classBigSig clas + + dm_ids = [dm_id | (_, dm_id, _) <- op_items] + -- Instantiate the theta found in the original instance decl + inst_decl_theta' = substClasses (mkTopTyVarSubst inst_tyvars (mkTyVarTys inst_tyvars')) + inst_decl_theta + + -- Instantiate the super-class context with inst_tys + sc_theta' = substClasses (mkTopTyVarSubst class_tyvars inst_tys') sc_theta + in -- Create dictionary Ids from the specified instance contexts. - newDicts origin sc_theta' `thenNF_Tc` \ (sc_dicts, sc_dict_ids) -> + newClassDicts origin sc_theta' `thenNF_Tc` \ (sc_dicts, sc_dict_ids) -> newDicts origin dfun_theta' `thenNF_Tc` \ (dfun_arg_dicts, dfun_arg_dicts_ids) -> - newDicts origin inst_decl_theta' `thenNF_Tc` \ (inst_decl_dicts, _) -> - newDicts origin [(clas,inst_tys')] `thenNF_Tc` \ (this_dict, [this_dict_id]) -> + newClassDicts origin inst_decl_theta' `thenNF_Tc` \ (inst_decl_dicts, _) -> + newClassDicts origin [(clas,inst_tys')] `thenNF_Tc` \ (this_dict, [this_dict_id]) -> -- Check that all the method bindings come from this class - let - check_from_this_class (bndr, loc) - | nameOccName bndr `elem` sel_names = returnNF_Tc () - | otherwise = tcAddSrcLoc loc $ - addErrTc (badMethodErr bndr clas) - sel_names = map getOccName op_sel_ids - bndrs = bagToList (collectMonoBinders monobinds) - in - mapNF_Tc check_from_this_class bndrs `thenNF_Tc_` - - tcExtendGlobalValEnv (catMaybes defm_ids) ( + checkFromThisClass clas op_items monobinds `thenNF_Tc_` + tcExtendTyVarEnvForMeths inst_tyvars inst_tyvars' ( + tcExtendGlobalValEnv dm_ids ( -- Default-method Ids may be mentioned in synthesised RHSs - mapAndUnzip3Tc (tcMethodBind clas origin inst_tys' inst_tyvars' monobinds uprags True) - (op_sel_ids `zip` defm_ids) - ) `thenTc` \ (method_binds_s, insts_needed_s, meth_lies_w_ids) -> - -- Deal with SPECIALISE instance pragmas + mapAndUnzip3Tc (tcMethodBind clas origin inst_tyvars' inst_tys' + (classesToPreds inst_decl_theta') + monobinds uprags True) + op_items + )) `thenTc` \ (method_binds_s, insts_needed_s, meth_lies_w_ids) -> + + -- Deal with SPECIALISE instance pragmas by making them + -- look like SPECIALISE pragmas for the dfun let - dfun_prags = [Sig (idName dfun_id) ty loc | SpecInstSig ty loc <- uprags] + dfun_prags = [SpecSig (idName dfun_id) ty loc | SpecInstSig ty loc <- uprags] in tcExtendGlobalValEnv [dfun_id] ( - tcPragmaSigs dfun_prags - ) `thenTc` \ (prag_info_fn, prag_binds, prag_lie) -> + tcSpecSigs dfun_prags + ) `thenTc` \ (prag_binds, prag_lie) -> -- Check the overloading constraints of the methods and superclasses - mapNF_Tc zonkSigTyVar inst_tyvars' `thenNF_Tc` \ zonked_inst_tyvars -> + -- tcMethodBind has checked that the class_tyvars havn't + -- been unified with each other or another type, but we must + -- still zonk them + mapNF_Tc zonkTcTyVarBndr inst_tyvars' `thenNF_Tc` \ zonked_inst_tyvars -> let - inst_tyvars_set = mkTyVarSet zonked_inst_tyvars + inst_tyvars_set = mkVarSet zonked_inst_tyvars (meth_lies, meth_ids) = unzip meth_lies_w_ids @@ -405,7 +403,7 @@ tcInstDecl2 (InstInfo clas inst_tyvars inst_tys inst_tyvars_set -- Local tyvars inst_decl_dicts -- The instance dictionaries available sc_dicts -- The superclass dicationaries reqd - ) `thenTc_` + ) `thenTc` \ _ -> -- Ignore the result; we're only doing -- this to make sure it can be done. @@ -435,26 +433,30 @@ tcInstDecl2 (InstInfo clas inst_tyvars inst_tys -- emit an error message. This in turn means that we don't -- mention the constructor, which doesn't exist for CCallable, CReturnable -- Hardly beautiful, but only three extra lines. - HsApp (TyApp (HsVar (RealId eRROR_ID)) [tcIdType this_dict_id]) + HsApp (TyApp (HsVar eRROR_ID) [(unUsgTy . idType) this_dict_id]) (HsLitOut (HsString msg) stringTy) | otherwise -- The common case - = HsCon dict_constr inst_tys' (map HsVar (sc_dict_ids ++ meth_ids)) + = mkHsConApp dict_constr inst_tys' (map HsVar (sc_dict_ids ++ meth_ids)) -- We don't produce a binding for the dict_constr; instead we - -- just generate the saturated constructor directly + -- rely on the simplifier to unfold this saturated application + -- We do this rather than generate an HsCon directly, because + -- it means that the special cases (e.g. dictionary with only one + -- member) are dealt with by the common MkId.mkDataConWrapId code rather + -- than needing to be repeated here. + where msg = _PK_ ("Compiler error: bad dictionary " ++ showSDoc (ppr clas)) dict_bind = VarMonoBind this_dict_id dict_rhs - method_binds = andMonoBinds method_binds_s + method_binds = andMonoBindList method_binds_s - final_dfun_id = replaceIdInfo dfun_id (prag_info_fn (idName dfun_id)) - -- Pretty truesome main_bind = AbsBinds zonked_inst_tyvars dfun_arg_dicts_ids - [(inst_tyvars', RealId final_dfun_id, this_dict_id)] + [(inst_tyvars', dfun_id, this_dict_id)] + emptyNameSet -- No inlines (yet) (lie_binds1 `AndMonoBinds` lie_binds2 `AndMonoBinds` method_binds `AndMonoBinds` @@ -482,26 +484,16 @@ We can also have instances for functions: @instance Foo (a -> b) ...@. \begin{code} scrutiniseInstanceConstraint (clas, tys) - | all isTyVarTy tys = returnNF_Tc () - | otherwise = addErrTc (instConstraintErr clas tys) + | all isTyVarTy tys + || opt_AllowUndecidableInstances = returnNF_Tc () + | otherwise = addErrTc (instConstraintErr clas tys) scrutiniseInstanceHead clas inst_taus - | -- CCALL CHECK (a).... urgh! - -- To verify that a user declaration of a CCallable/CReturnable - -- instance is OK, we must be able to see the constructor(s) - -- of the instance type (see next guard.) - -- - -- We flag this separately to give a more precise error msg. - -- - (uniqueOf clas == cCallableClassKey || uniqueOf clas == cReturnableClassKey) - && is_alg_tycon_app && not constructors_visible - = addErrTc (invisibleDataConPrimCCallErr clas first_inst_tau) - - | -- CCALL CHECK (b) + | -- CCALL CHECK -- A user declaration of a CCallable/CReturnable instance -- must be for a "boxed primitive" type. - (uniqueOf clas == cCallableClassKey && not (ccallable_type first_inst_tau)) || - (uniqueOf clas == cReturnableClassKey && not (creturnable_type first_inst_tau)) + (clas `hasKey` cCallableClassKey && not (ccallable_type first_inst_tau)) || + (clas `hasKey` cReturnableClassKey && not (creturnable_type first_inst_tau)) = addErrTc (nonBoxedPrimCCallErr clas first_inst_tau) -- DERIVING CHECK @@ -511,13 +503,23 @@ scrutiniseInstanceHead clas inst_taus = addErrTc (derivingWhenInstanceExistsErr clas first_inst_tau) -- Kind check will have ensured inst_taus is of length 1 + -- Allow anything for AllowUndecidableInstances + | opt_AllowUndecidableInstances + = returnNF_Tc () + + -- If GlasgowExts then check at least one isn't a type variable + | opt_GlasgowExts + = if all isTyVarTy inst_taus then + addErrTc (instTypeErr clas inst_taus (text "There must be at least one non-type-variable in the instance head")) + else + returnNF_Tc () + -- WITH HASKELL 1.4, MUST HAVE C (T a b c) - | not opt_GlasgowExts - && not (length inst_taus == 1 && + | not (length inst_taus == 1 && maybeToBool maybe_tycon_app && -- Yes, there's a type constuctor not (isSynTyCon tycon) && -- ...but not a synonym all isTyVarTy arg_tys && -- Applied to type variables - length (tyVarSetToList (tyVarsOfTypes arg_tys)) == length arg_tys + length (varSetElems (tyVarsOfTypes arg_tys)) == length arg_tys -- This last condition checks that all the type variables are distinct ) = addErrTc (instTypeErr clas inst_taus @@ -536,47 +538,17 @@ scrutiniseInstanceHead clas inst_taus Just (tycon, arg_tys) = maybe_tycon_app -- Stuff for an *algebraic* data type - alg_tycon_app_maybe = splitAlgTyConApp_maybe first_inst_tau - -- The "Alg" part looks through synonyms - is_alg_tycon_app = maybeToBool alg_tycon_app_maybe - Just (alg_tycon, _, data_cons) = alg_tycon_app_maybe - - constructors_visible = not (null data_cons) + alg_tycon_app_maybe = splitAlgTyConApp_maybe first_inst_tau + -- The "Alg" part looks through synonyms + Just (alg_tycon, _, _) = alg_tycon_app_maybe - --- These conditions come directly from what the DsCCall is capable of. --- Totally grotesque. Green card should solve this. - -ccallable_type ty = isUnpointedType ty || -- Allow CCallable Int# etc - maybeToBool (maybeBoxedPrimType ty) || -- Ditto Int etc - ty == stringTy || - byte_arr_thing - where - byte_arr_thing = case splitAlgTyConApp_maybe ty of - Just (tycon, ty_args, [data_con]) | isDataTyCon tycon -> - length data_con_arg_tys == 2 && - maybeToBool maybe_arg2_tycon && - (arg2_tycon == byteArrayPrimTyCon || - arg2_tycon == mutableByteArrayPrimTyCon) - where - data_con_arg_tys = dataConArgTys data_con ty_args - (data_con_arg_ty1 : data_con_arg_ty2 : _) = data_con_arg_tys - maybe_arg2_tycon = splitTyConApp_maybe data_con_arg_ty2 - Just (arg2_tycon,_) = maybe_arg2_tycon - - other -> False - -creturnable_type ty = maybeToBool (maybeBoxedPrimType ty) || - -- Or, a data type with a single nullary constructor - case (splitAlgTyConApp_maybe ty) of - Just (tycon, tys_applied, [data_con]) - -> isNullaryDataCon data_con - other -> False +ccallable_type ty = isFFIArgumentTy False {- Not safe call -} ty +creturnable_type ty = isFFIResultTy ty \end{code} \begin{code} instConstraintErr clas tys - = hang (ptext SLIT("Illegal constaint") <+> + = hang (ptext SLIT("Illegal constraint") <+> quotes (pprConstraint clas tys) <+> ptext SLIT("in instance context")) 4 (ptext SLIT("(Instance contexts must constrain only type variables)")) @@ -597,19 +569,6 @@ nonBoxedPrimCCallErr clas inst_ty 4 (hsep [ ptext SLIT("class"), ppr clas, ptext SLIT("type"), ppr inst_ty]) -{- - Declaring CCallable & CReturnable instances in a module different - from where the type was defined. Caused by importing data type - abstractly (either programmatically or by the renamer being over-eager - in its pruning.) --} -invisibleDataConPrimCCallErr clas inst_ty - = hang (hsep [ptext SLIT("Constructors for"), quotes (ppr inst_ty), - ptext SLIT("not visible when checking"), - quotes (ppr clas), ptext SLIT("instance")]) - 4 (hsep [text "(Try either importing", ppr inst_ty, - text "non-abstractly or compile using -fno-prune-tydecls ..)"]) - methodCtxt = ptext SLIT("When checking the methods of an instance declaration") superClassCtxt = ptext SLIT("When checking the superclasses of an instance declaration") \end{code}