-- 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
when the dict is constructed in TcInstDcls.tcInstDecl2
-
+Note [Unused constructors and deriving clauses]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+See Trac #3221. Consider
+ data T = T1 | T2 deriving( Show )
+Are T1 and T2 unused? Well, no: the deriving clause expands to mention
+both of them. So we gather defs/uses from deriving just like anything else.
%************************************************************************
%* *
-> [LInstDecl Name] -- All instance declarations
-> [LDerivDecl Name] -- All stand-alone deriving declarations
-> TcM ([InstInfo Name], -- The generated "instance decls"
- HsValBinds Name) -- Extra generated top-level bindings
+ HsValBinds Name, -- Extra generated top-level bindings
+ DefUses)
tcDeriving tycl_decls inst_decls deriv_decls
- = recoverM (return ([], emptyValBindsOut)) $
+ = recoverM (return ([], emptyValBindsOut, emptyDUs)) $
do { -- Fish the "deriving"-related information out of the TcEnv
-- And make the necessary "equations".
is_boot <- tcIsHsBoot
; overlap_flag <- getOverlapFlag
; let (infer_specs, given_specs) = splitEithers early_specs
- ; insts1 <- mapM (genInst overlap_flag) given_specs
+ ; insts1 <- mapM (genInst True overlap_flag) given_specs
; final_specs <- extendLocalInstEnv (map (iSpec . fst) insts1) $
inferInstanceContexts overlap_flag infer_specs
- ; insts2 <- mapM (genInst overlap_flag) final_specs
+ ; insts2 <- mapM (genInst False overlap_flag) final_specs
-- Generate the generic to/from functions from each type declaration
- ; gen_binds <- mkGenericBinds is_boot
- ; (inst_info, rn_binds) <- renameDeriv is_boot gen_binds (insts1 ++ insts2)
+ ; gen_binds <- mkGenericBinds is_boot tycl_decls
+ ; (inst_info, rn_binds, rn_dus) <- renameDeriv is_boot gen_binds (insts1 ++ insts2)
; dflags <- getDOpts
; liftIO (dumpIfSet_dyn dflags Opt_D_dump_deriv "Derived instances"
(ddump_deriving inst_info rn_binds))
- ; return (inst_info, rn_binds) }
+ ; return (inst_info, rn_binds, rn_dus) }
where
ddump_deriving :: [InstInfo Name] -> HsValBinds Name -> SDoc
ddump_deriving inst_infos extra_binds
renameDeriv :: Bool -> LHsBinds RdrName
-> [(InstInfo RdrName, DerivAuxBinds)]
- -> TcM ([InstInfo Name], HsValBinds Name)
+ -> TcM ([InstInfo Name], HsValBinds Name, DefUses)
renameDeriv is_boot gen_binds insts
| is_boot -- If we are compiling a hs-boot file, don't generate any derived bindings
-- The inst-info bindings will all be empty, but it's easier to
-- just use rn_inst_info to change the type appropriately
- = do { rn_inst_infos <- mapM rn_inst_info inst_infos
- ; return (rn_inst_infos, emptyValBindsOut) }
+ = do { (rn_inst_infos, fvs) <- mapAndUnzipM rn_inst_info inst_infos
+ ; return (rn_inst_infos, emptyValBindsOut, usesOnly (plusFVs fvs)) }
| otherwise
= discardWarnings $ -- Discard warnings about unused bindings etc
; let aux_names = map unLoc (collectHsValBinders rn_aux_lhs)
; bindLocalNames aux_names $
- do { (rn_aux, _dus) <- rnTopBindsRHS (mkNameSet aux_names) rn_aux_lhs
- ; rn_inst_infos <- mapM rn_inst_info inst_infos
- ; return (rn_inst_infos, rn_aux `plusHsValBinds` rn_gen) } }
+ do { (rn_aux, dus_aux) <- rnTopBindsRHS (mkNameSet aux_names) rn_aux_lhs
+ ; (rn_inst_infos, fvs_insts) <- mapAndUnzipM rn_inst_info inst_infos
+ ; return (rn_inst_infos, rn_aux `plusHsValBinds` rn_gen,
+ dus_gen `plusDU` dus_aux `plusDU` usesOnly (plusFVs fvs_insts)) } }
where
(inst_infos, deriv_aux_binds) = unzip insts
rn_inst_info (InstInfo { iSpec = inst, iBinds = NewTypeDerived co })
- = return (InstInfo { iSpec = inst, iBinds = NewTypeDerived co })
+ = return (InstInfo { iSpec = inst, iBinds = NewTypeDerived co }, emptyFVs)
- rn_inst_info (InstInfo { iSpec = inst, iBinds = VanillaInst binds sigs })
+ rn_inst_info (InstInfo { iSpec = inst, iBinds = VanillaInst binds sigs standalone_deriv })
= -- Bring the right type variables into
-- scope (yuk), and rename the method binds
ASSERT( null sigs )
bindLocalNames (map Var.varName tyvars) $
- do { (rn_binds, _fvs) <- rnMethodBinds clas_nm (\_ -> []) [] binds
- ; return (InstInfo { iSpec = inst, iBinds = VanillaInst rn_binds [] }) }
+ do { (rn_binds, fvs) <- rnMethodBinds clas_nm (\_ -> []) [] binds
+ ; 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 -> TcM (LHsBinds RdrName)
-mkGenericBinds is_boot
+mkGenericBinds :: Bool -> [LTyClDecl Name] -> TcM (LHsBinds RdrName)
+mkGenericBinds is_boot tycl_decls
| is_boot
= return emptyBag
| otherwise
- = do { gbl_env <- getGblEnv
- ; let tcs = typeEnvTyCons (tcg_type_env gbl_env)
- ; return (unionManyBags [ mkTyConGenericBinds tc |
- tc <- tcs, tyConHasGenerics tc ]) }
+ = do { tcs <- mapM tcLookupTyCon [ tcdName d
+ | L _ d <- tycl_decls, isDataDecl d ]
+ ; return (unionManyBags [ mkTyConGenericBinds tc
+ | tc <- tcs, tyConHasGenerics tc ]) }
-- We are only interested in the data type declarations,
-- and then only in the ones whose 'has-generics' flag is on
-- The predicate tyConHasGenerics finds both of these
<+> 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
\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
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}
-> [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
- = case checkSideConditions dflags cls cls_tys rep_tc of
+ = case checkSideConditions dflags mtheta cls cls_tys rep_tc of
-- NB: pass the *representation* tycon to checkSideConditions
- CanDerive -> mk_data_eqn orig tvs cls tycon tc_args rep_tc rep_tc_args mtheta
+ CanDerive -> go_for_it
NonDerivableClass -> bale_out (nonStdErr cls)
DerivableClassError msg -> bale_out msg
where
- bale_out msg = failWithTc (derivingThingErr cls cls_tys (mkTyConApp tycon tc_args) msg)
+ go_for_it = mk_data_eqn orig tvs cls tycon tc_args rep_tc rep_tc_args mtheta
+ 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
| 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
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
| cls_key == enumClassKey = Just (cond_std `andCond` cond_isEnumeration)
| cls_key == ixClassKey = Just (cond_std `andCond` cond_enumOrProduct)
| cls_key == boundedClassKey = Just (cond_std `andCond` cond_enumOrProduct)
- | cls_key == dataClassKey = Just (cond_mayDeriveDataTypeable `andCond` cond_std `andCond` cond_noUnliftedArgs)
- | cls_key == functorClassKey = Just (cond_std `andCond` cond_functorOK True)
- | cls_key == foldableClassKey = Just (cond_std `andCond` cond_functorOK False)
- | cls_key == traversableClassKey = Just (cond_std `andCond` cond_functorOK False)
- | getName cls `elem` typeableClassNames = Just (cond_mayDeriveDataTypeable `andCond` cond_typeableOK)
+ | cls_key == dataClassKey = Just (checkFlag Opt_DeriveDataTypeable `andCond`
+ cond_std `andCond` cond_noUnliftedArgs)
+ | cls_key == functorClassKey = Just (checkFlag Opt_DeriveFunctor `andCond`
+ cond_functorOK True) -- NB: no cond_std!
+ | cls_key == foldableClassKey = Just (checkFlag Opt_DeriveFoldable `andCond`
+ cond_functorOK False) -- Functor/Fold/Trav works ok for rank-n types
+ | cls_key == traversableClassKey = Just (checkFlag Opt_DeriveTraversable `andCond`
+ cond_functorOK False)
+ | getName cls `elem` typeableClassNames = Just (checkFlag Opt_DeriveDataTypeable `andCond` cond_typeableOK)
| 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
Nothing -> c2 tc -- c1 succeeds
Just x -> Just x -- c1 fails
-cond_std :: Condition
-cond_std (_, rep_tc)
- | any (not . isVanillaDataCon) data_cons = Just existential_why
- | null data_cons = Just no_cons_why
- | otherwise = Nothing
+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")
- existential_why = quotes (pprSourceTyCon rep_tc) <+>
- ptext (sLit "has non-Haskell-98 constructor(s)")
+ 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
+
+ check_con :: DataCon -> Maybe SDoc
+ check_con con
+ | isVanillaDataCon con
+ , all isTauTy (dataConOrigArgTys con) = Nothing
+ | otherwise = Just (badCon con (ptext (sLit "does not have a Haskell-98 type")))
cond_enumOrProduct :: Condition
cond_enumOrProduct = cond_isEnumeration `orCond`
where
bad_cons = [ con | con <- tyConDataCons tc
, any isUnLiftedType (dataConOrigArgTys con) ]
- why = ptext (sLit "Constructor") <+> quotes (ppr (head bad_cons))
- <+> ptext (sLit "has arguments of unlifted type")
+ why = badCon (head bad_cons) (ptext (sLit "has arguments of unlifted type"))
cond_isEnumeration :: Condition
cond_isEnumeration (_, rep_tc)
= msum (map check_con data_cons) -- msum picks the first 'Just', if any
where
data_cons = tyConDataCons rep_tc
- check_con con = msum (foldDataConArgs ft_check con)
-
- ft_check :: FFoldType (Maybe SDoc)
- ft_check = FT { ft_triv = Nothing, ft_var = Nothing, ft_co_var = Just covariant
- , ft_fun = \x y -> if allowFunctions then x `mplus` y else Just functions
- , ft_tup = \_ xs -> msum xs
- , ft_ty_app = \_ x -> x
- , ft_bad_app = Just wrong_arg
- , ft_forall = \_ x -> x }
+ check_con con = msum (check_vanilla con : foldDataConArgs (ft_check con) con)
+
+ check_vanilla :: DataCon -> Maybe SDoc
+ check_vanilla con | isVanillaDataCon con = Nothing
+ | otherwise = Just (badCon con existential)
+
+ ft_check :: DataCon -> FFoldType (Maybe SDoc)
+ ft_check con = FT { ft_triv = Nothing, ft_var = Nothing
+ , ft_co_var = Just (badCon con covariant)
+ , ft_fun = \x y -> if allowFunctions then x `mplus` y
+ else Just (badCon con functions)
+ , ft_tup = \_ xs -> msum xs
+ , ft_ty_app = \_ x -> x
+ , ft_bad_app = Just (badCon con wrong_arg)
+ , ft_forall = \_ x -> x }
- covariant = quotes (pprSourceTyCon rep_tc) <+>
- ptext (sLit "uses the type variable in a function argument")
- functions = quotes (pprSourceTyCon rep_tc) <+>
- ptext (sLit "contains function types")
- wrong_arg = quotes (pprSourceTyCon rep_tc) <+>
- ptext (sLit "uses the type variable in an argument other than the last")
-
-cond_mayDeriveDataTypeable :: Condition
-cond_mayDeriveDataTypeable (dflags, _)
- | dopt Opt_DeriveDataTypeable dflags = Nothing
- | otherwise = Just why
+ existential = ptext (sLit "has existential arguments")
+ covariant = ptext (sLit "uses the type variable in a function argument")
+ functions = ptext (sLit "contains function types")
+ wrong_arg = ptext (sLit "uses the type variable in an argument other than the last")
+
+checkFlag :: DynFlag -> Condition
+checkFlag flag (dflags, _)
+ | dopt flag dflags = Nothing
+ | otherwise = Just why
where
- why = ptext (sLit "You need -XDeriveDataTypeable to derive an instance for this class")
+ why = ptext (sLit "You need -X") <> text flag_str
+ <+> ptext (sLit "to derive an instance for this class")
+ flag_str = case [ s | (s, f, _) <- xFlags, f==flag ] of
+ [s] -> s
+ 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
; newDFunName clas [mkTyConApp tycon []] loc }
-- The type passed to newDFunName is only used to generate
-- a suitable string; hence the empty type arg list
+
+badCon :: DataCon -> SDoc -> SDoc
+badCon con msg = ptext (sLit "Constructor") <+> quotes (ppr con) <+> msg
\end{code}
Note [Superclasses of derived instance]
\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
else Left spec) }
| otherwise
- = case check_conditions of
- CanDerive -> mk_data_eqn orig tvs cls tycon tc_args rep_tycon rep_tc_args mtheta
- -- 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 -> bale_out msg -- Error with standard class
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!
where
newtype_deriving = dopt Opt_GeneralizedNewtypeDeriving dflags
- check_conditions = checkSideConditions dflags cls cls_tys rep_tycon
- bale_out msg = failWithTc (derivingThingErr cls cls_tys inst_ty msg)
+ go_for_it = mk_data_eqn orig tvs cls tycon tc_args rep_tycon rep_tc_args mtheta
+ 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")
-- 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")
-- Representation tycons differ from the tycon in the instance signature in
-- case of instances for indexed families.
--
-genInst :: OverlapFlag -> DerivSpec -> TcM (InstInfo RdrName, DerivAuxBinds)
-genInst oflag spec
+genInst :: Bool -- True <=> standalone deriving
+ -> OverlapFlag
+ -> DerivSpec -> TcM (InstInfo RdrName, DerivAuxBinds)
+genInst standalone_deriv oflag spec
| ds_newtype spec
= return (InstInfo { iSpec = mkInstance oflag (ds_theta spec) spec
, iBinds = NewTypeDerived co }, [])
| otherwise
- = do { let loc = getSrcSpan (ds_name spec)
- inst = mkInstance oflag (ds_theta spec) spec
- clas = ds_cls spec
+ = do { let loc = getSrcSpan (ds_name spec)
+ inst = mkInstance oflag (ds_theta spec) spec
+ clas = ds_cls spec
-- In case of a family instance, we need to use the representation
-- tycon (after all, it has the data constructors)
; fix_env <- getFixityEnv
; let (meth_binds, aux_binds) = genDerivBinds loc fix_env clas rep_tycon
-
- -- Build the InstInfo
- ; return (InstInfo { iSpec = inst,
- iBinds = VanillaInst meth_binds [] },
- aux_binds)
+ binds = VanillaInst meth_binds [] standalone_deriv
+ ; return (InstInfo { iSpec = inst, iBinds = binds }, aux_binds)
}
where
rep_tycon = ds_tc 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
= 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