X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcDeriv.lhs;h=b60a9be907d94fc627d269a45165614c3e88a833;hb=e9f9ec1e57d53b9302a395ce0d02c0fa59e28341;hp=4aa2089e8b9b1df13a843aae64d2cf650c689ee9;hpb=27bc28577451bf2c2f011b2821ef670373e46ced;p=ghc-hetmet.git diff --git a/compiler/typecheck/TcDeriv.lhs b/compiler/typecheck/TcDeriv.lhs index 4aa2089..b60a9be 100644 --- a/compiler/typecheck/TcDeriv.lhs +++ b/compiler/typecheck/TcDeriv.lhs @@ -92,6 +92,10 @@ data DerivSpec = DS { ds_loc :: SrcSpan -- ds_newtype = True <=> Newtype deriving -- False <=> Vanilla deriving +type DerivContext = Maybe ThetaType + -- Nothing <=> Vanilla deriving; infer the context of the instance decl + -- Just theta <=> Standalone deriving: context supplied by programmer + type EarlyDerivSpec = Either DerivSpec DerivSpec -- Left ds => the context for the instance should be inferred -- In this case ds_theta is the list of all the @@ -362,8 +366,8 @@ renameDeriv is_boot gen_binds insts ; let binds' = VanillaInst rn_binds [] standalone_deriv ; return (InstInfo { iSpec = inst, iBinds = binds' }, fvs) } where - (tyvars,_,clas,_) = instanceHead inst - clas_nm = className clas + (tyvars,_, clas,_) = instanceHead inst + clas_nm = className clas ----------------------------------------- mkGenericBinds :: Bool -> [LTyClDecl Name] -> TcM (LHsBinds RdrName) @@ -436,8 +440,7 @@ deriveStandalone (L loc (DerivDecl deriv_ty)) <+> text "tvs:" <+> ppr tvs <+> text "theta:" <+> ppr theta <+> text "tau:" <+> ppr tau) - ; (cls, inst_tys) <- checkValidInstHead tau - ; checkValidInstance tvs theta cls inst_tys + ; (cls, inst_tys) <- checkValidInstance deriv_ty tvs theta tau -- C.f. TcInstDcls.tcLocalInstDecl1 ; let cls_tys = take (length inst_tys - 1) inst_tys @@ -549,7 +552,7 @@ After all, we can write it out \begin{code} mkEqnHelp :: InstOrigin -> [TyVar] -> Class -> [Type] -> Type - -> Maybe ThetaType -- Just => context supplied (standalone deriving) + -> DerivContext -- Just => context supplied (standalone deriving) -- Nothing => context inferred (deriving on data decl) -> TcRn EarlyDerivSpec -- Make the EarlyDerivSpec for an instance @@ -584,7 +587,7 @@ mkEqnHelp orig tvs cls cls_tys tc_app mtheta mkNewTypeEqn orig dflags tvs cls cls_tys tycon tc_args rep_tc rep_tc_args mtheta } | otherwise - = failWithTc (derivingThingErr cls cls_tys tc_app + = failWithTc (derivingThingErr False cls cls_tys tc_app (ptext (sLit "The last argument of the instance must be a data or newtype application"))) \end{code} @@ -643,28 +646,28 @@ mkDataTypeEqn :: InstOrigin -> [Var] -- Universally quantified type variables in the instance -> Class -- Class for which we need to derive an instance -> [Type] -- Other parameters to the class except the last - -> TyCon -- Type constructor for which the instance is requested (last parameter to the type class) + -> TyCon -- Type constructor for which the instance is requested + -- (last parameter to the type class) -> [Type] -- Parameters to the type constructor -> TyCon -- rep of the above (for type families) -> [Type] -- rep of the above - -> Maybe ThetaType -- Context of the instance, for standalone deriving + -> DerivContext -- Context of the instance, for standalone deriving -> TcRn EarlyDerivSpec -- Return 'Nothing' if error mkDataTypeEqn orig dflags tvs cls cls_tys tycon tc_args rep_tc rep_tc_args mtheta - | isJust mtheta = go_for_it -- Do not test side conditions for standalone deriving - | otherwise = case checkSideConditions dflags cls cls_tys rep_tc of - -- NB: pass the *representation* tycon to checkSideConditions - CanDerive -> go_for_it - NonDerivableClass -> bale_out (nonStdErr cls) - DerivableClassError msg -> bale_out msg + = case checkSideConditions dflags mtheta cls cls_tys rep_tc of + -- NB: pass the *representation* tycon to checkSideConditions + CanDerive -> go_for_it + NonDerivableClass -> bale_out (nonStdErr cls) + DerivableClassError msg -> bale_out msg where go_for_it = mk_data_eqn orig tvs cls tycon tc_args rep_tc rep_tc_args mtheta - bale_out msg = failWithTc (derivingThingErr cls cls_tys (mkTyConApp tycon tc_args) msg) + bale_out msg = failWithTc (derivingThingErr False cls cls_tys (mkTyConApp tycon tc_args) msg) mk_data_eqn, mk_typeable_eqn :: InstOrigin -> [TyVar] -> Class - -> TyCon -> [TcType] -> TyCon -> [TcType] -> Maybe ThetaType + -> TyCon -> [TcType] -> TyCon -> [TcType] -> DerivContext -> TcM EarlyDerivSpec mk_data_eqn orig tvs cls tycon tc_args rep_tc rep_tc_args mtheta | getName cls `elem` typeableClassNames @@ -781,12 +784,14 @@ data DerivStatus = CanDerive | DerivableClassError SDoc -- Standard class, but can't do it | NonDerivableClass -- Non-standard class -checkSideConditions :: DynFlags -> Class -> [TcType] -> TyCon -> DerivStatus -checkSideConditions dflags cls cls_tys rep_tc - | Just cond <- sideConditions cls +checkSideConditions :: DynFlags -> DerivContext -> Class -> [TcType] -> TyCon -> DerivStatus +checkSideConditions dflags mtheta cls cls_tys rep_tc + | Just cond <- sideConditions mtheta cls = case (cond (dflags, rep_tc)) of Just err -> DerivableClassError err -- Class-specific error - Nothing | null cls_tys -> CanDerive + Nothing | null cls_tys -> CanDerive -- All derivable classes are unary, so + -- cls_tys (the type args other than last) + -- should be null | otherwise -> DerivableClassError ty_args_why -- e.g. deriving( Eq s ) | otherwise = NonDerivableClass -- Not a standard class where @@ -795,8 +800,8 @@ checkSideConditions dflags cls cls_tys rep_tc nonStdErr :: Class -> SDoc nonStdErr cls = quotes (ppr cls) <+> ptext (sLit "is not a derivable class") -sideConditions :: Class -> Maybe Condition -sideConditions cls +sideConditions :: DerivContext -> Class -> Maybe Condition +sideConditions mtheta cls | cls_key == eqClassKey = Just cond_std | cls_key == ordClassKey = Just cond_std | cls_key == showClassKey = Just cond_std @@ -816,6 +821,7 @@ sideConditions cls | otherwise = Nothing where cls_key = getUnique cls + cond_std = cond_stdOK mtheta type Condition = (DynFlags, TyCon) -> Maybe SDoc -- first Bool is whether or not we are allowed to derive Data and Typeable @@ -838,15 +844,19 @@ andCond c1 c2 tc = case c1 tc of Nothing -> c2 tc -- c1 succeeds Just x -> Just x -- c1 fails -cond_std :: Condition -cond_std (_, rep_tc) - | null data_cons = Just no_cons_why - | not (null con_whys) = Just (vcat con_whys) +cond_stdOK :: DerivContext -> Condition +cond_stdOK (Just _) _ + = Nothing -- Don't check these conservative conditions for + -- standalone deriving; just generate the code +cond_stdOK Nothing (_, rep_tc) + | null data_cons = Just (no_cons_why $$ suggestion) + | not (null con_whys) = Just (vcat con_whys $$ suggestion) | otherwise = Nothing where - data_cons = tyConDataCons rep_tc - no_cons_why = quotes (pprSourceTyCon rep_tc) <+> - ptext (sLit "has no data constructors") + suggestion = ptext (sLit "Possible fix: use a standalone deriving declaration instead") + data_cons = tyConDataCons rep_tc + no_cons_why = quotes (pprSourceTyCon rep_tc) <+> + ptext (sLit "has no data constructors") con_whys = mapCatMaybes check_con data_cons @@ -955,13 +965,25 @@ checkFlag flag (dflags, _) other -> pprPanic "checkFlag" (ppr other) std_class_via_iso :: Class -> Bool -std_class_via_iso clas -- These standard classes can be derived for a newtype - -- using the isomorphism trick *even if no -fglasgow-exts* +-- These standard classes can be derived for a newtype +-- using the isomorphism trick *even if no -XGeneralizedNewtypeDeriving +-- because giving so gives the same results as generating the boilerplate +std_class_via_iso clas = classKey clas `elem` [eqClassKey, ordClassKey, ixClassKey, boundedClassKey] -- Not Read/Show because they respect the type -- Not Enum, because newtypes are never in Enum +non_iso_class :: Class -> Bool +-- *Never* derive Read,Show,Typeable,Data by isomorphism, +-- even with -XGeneralizedNewtypeDeriving +non_iso_class cls + = classKey cls `elem` ([readClassKey, showClassKey, dataClassKey] ++ + typeableClassKeys) + +typeableClassKeys :: [Unique] +typeableClassKeys = map getUnique typeableClassNames + new_dfun_name :: Class -> TyCon -> TcM Name new_dfun_name clas tycon -- Just a simple wrapper = do { loc <- getSrcSpanM -- The location of the instance decl, not of the tycon @@ -1007,7 +1029,7 @@ a context for the Data instances: \begin{code} mkNewTypeEqn :: InstOrigin -> DynFlags -> [Var] -> Class -> [Type] -> TyCon -> [Type] -> TyCon -> [Type] - -> Maybe ThetaType + -> DerivContext -> TcRn EarlyDerivSpec mkNewTypeEqn orig dflags tvs cls cls_tys tycon tc_args rep_tycon rep_tc_args mtheta @@ -1025,21 +1047,23 @@ mkNewTypeEqn orig dflags tvs ; return (if isJust mtheta then Right spec else Left spec) } - | isJust mtheta = go_for_it -- Do not check side conditions for standalone deriving | otherwise - = case checkSideConditions dflags cls cls_tys rep_tycon of - CanDerive -> go_for_it -- Use the standard H98 method - DerivableClassError msg -> bale_out msg -- Error with standard class + = case checkSideConditions dflags mtheta cls cls_tys rep_tycon of + CanDerive -> go_for_it -- Use the standard H98 method + DerivableClassError msg -- Error with standard class + | can_derive_via_isomorphism -> bale_out (msg $$ suggest_nd) + | otherwise -> bale_out msg NonDerivableClass -- Must use newtype deriving - | newtype_deriving -> bale_out cant_derive_err -- Too hard, even with newtype deriving - | otherwise -> bale_out non_std_err -- Try newtype deriving! + | newtype_deriving -> bale_out cant_derive_err -- Too hard, even with newtype deriving + | can_derive_via_isomorphism -> bale_out (non_std $$ suggest_nd) -- Try newtype deriving! + | otherwise -> bale_out non_std where newtype_deriving = dopt Opt_GeneralizedNewtypeDeriving dflags go_for_it = mk_data_eqn orig tvs cls tycon tc_args rep_tycon rep_tc_args mtheta - bale_out msg = failWithTc (derivingThingErr cls cls_tys inst_ty msg) + bale_out msg = failWithTc (derivingThingErr newtype_deriving cls cls_tys inst_ty msg) - non_std_err = nonStdErr cls $$ - ptext (sLit "Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension") + non_std = nonStdErr cls + suggest_nd = ptext (sLit "Try -XGeneralizedNewtypeDeriving for GHC's newtype-deriving extension") -- Here is the plan for newtype derivings. We see -- newtype T a1...an = MkT (t ak+1...an) deriving (.., C s1 .. sm, ...) @@ -1123,10 +1147,6 @@ mkNewTypeEqn orig dflags tvs && ats_ok -- && not (isRecursiveTyCon tycon) -- Note [Recursive newtypes] - -- Never derive Read,Show,Typeable,Data by isomorphism - non_iso_class cls = className cls `elem` ([readClassName, showClassName, dataClassName] ++ - typeableClassNames) - arity_ok = length cls_tys + 1 == classArity cls -- Well kinded; eg not: newtype T ... deriving( ST ) -- because ST needs *2* type params @@ -1146,10 +1166,9 @@ mkNewTypeEqn orig dflags tvs -- so for 'data' instance decls cant_derive_err - = vcat [ ptext (sLit "even with cunning newtype deriving:") - , if arity_ok then empty else arity_msg - , if eta_ok then empty else eta_msg - , if ats_ok then empty else ats_msg ] + = vcat [ ppUnless arity_ok arity_msg + , ppUnless eta_ok eta_msg + , ppUnless ats_ok ats_msg ] arity_msg = quotes (ppr (mkClassPred cls cls_tys)) <+> ptext (sLit "does not have arity 1") eta_msg = ptext (sLit "cannot eta-reduce the representation type enough") ats_msg = ptext (sLit "the class has associated types") @@ -1387,6 +1406,7 @@ genInst standalone_deriv oflag spec -- When dealing with the deriving clause -- co1 : N [(b,b)] ~ R1:N (b,b) -- co2 : R1:N (b,b) ~ Tree (b,b) +-- co : N [(b,b)] ~ Tree (b,b) genDerivBinds :: SrcSpan -> FixityEnv -> Class -> TyCon -> (LHsBinds RdrName, DerivAuxBinds) genDerivBinds loc fix_env clas tycon @@ -1439,12 +1459,15 @@ typeFamilyPapErr tc cls cls_tys inst_ty = hang (ptext (sLit "Derived instance") <+> quotes (pprClassPred cls (cls_tys ++ [inst_ty]))) 2 (ptext (sLit "requires illegal partial application of data type family") <+> ppr tc) -derivingThingErr :: Class -> [Type] -> Type -> Message -> Message -derivingThingErr clas tys ty why - = sep [hsep [ptext (sLit "Can't make a derived instance of"), - quotes (ppr pred)], - nest 2 (parens why)] +derivingThingErr :: Bool -> Class -> [Type] -> Type -> Message -> Message +derivingThingErr newtype_deriving clas tys ty why + = sep [(hang (ptext (sLit "Can't make a derived instance of")) + 2 (quotes (ppr pred)) + $$ nest 2 extra) <> colon, + nest 2 why] where + extra | newtype_deriving = ptext (sLit "(even with cunning newtype deriving)") + | otherwise = empty pred = mkClassPred clas (tys ++ [ty]) derivingHiddenErr :: TyCon -> SDoc