%
+% (c) The University of Glasgow 2006
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\begin{code}
module BuildTyCl (
- buildSynTyCon, buildAlgTyCon, buildDataCon,
- buildClass,
- mkAbstractTyConRhs, mkOpenDataTyConRhs, mkOpenNewTyConRhs,
- mkNewTyConRhs, mkDataTyConRhs
+ buildSynTyCon,
+ buildAlgTyCon,
+ buildDataCon,
+ TcMethInfo, buildClass,
+ mkAbstractTyConRhs,
+ mkNewTyConRhs, mkDataTyConRhs
) where
#include "HsVersions.h"
-import IfaceEnv ( newImplicitBinder )
-import TcRnMonad
+import IfaceEnv
-import DataCon ( DataCon, isNullarySrcDataCon, dataConUnivTyVars,
- mkDataCon, dataConFieldLabels, dataConInstOrigArgTys,
- dataConTyCon )
-import Var ( tyVarKind, TyVar, Id )
-import VarSet ( isEmptyVarSet, intersectVarSet, elemVarSet )
-import TysWiredIn ( unitTy )
-import BasicTypes ( RecFlag, StrictnessMark(..) )
-import Name ( Name )
-import OccName ( mkDataConWrapperOcc, mkDataConWorkerOcc,
- mkClassTyConOcc, mkClassDataConOcc,
- mkSuperDictSelOcc, mkNewTyCoOcc, mkInstTyTcOcc,
- mkInstTyCoOcc )
-import MkId ( mkDataConIds, mkRecordSelId, mkDictSelId )
-import Class ( mkClass, Class( classTyCon), FunDep, DefMeth(..) )
-import TyCon ( mkSynTyCon, mkAlgTyCon, visibleDataCons,
- tyConStupidTheta, tyConDataCons, isNewTyCon,
- mkClassTyCon, TyCon( tyConTyVars ),
- isRecursiveTyCon, tyConArity, AlgTyConRhs(..),
- SynTyConRhs(..), newTyConRhs, AlgTyConParent(..) )
-import Type ( mkArrowKinds, liftedTypeKind, typeKind,
- tyVarsOfType, tyVarsOfTypes, tyVarsOfPred,
- splitTyConApp_maybe, splitAppTy_maybe,
- getTyVar_maybe,
- mkPredTys, mkTyVarTys, ThetaType, Type, Kind,
- TyThing(..),
- substTyWith, zipTopTvSubst, substTheta, mkForAllTys,
- mkTyConApp, mkTyVarTy )
-import Coercion ( mkNewTypeCoercion, mkDataInstCoercion )
-import Outputable
-import List ( nub )
+import DataCon
+import Var
+import VarSet
+import BasicTypes
+import Name
+import MkId
+import Class
+import TyCon
+import Type
+import Coercion
+import TcRnMonad
+import Data.List ( partition )
+import Outputable
\end{code}
\begin{code}
------------------------------------------------------
-buildSynTyCon :: Name -> [TyVar] -> SynTyConRhs -> TyCon
-buildSynTyCon name tvs rhs@(OpenSynTyCon rhs_ki)
- = mkSynTyCon name kind tvs rhs
+buildSynTyCon :: Name -> [TyVar]
+ -> SynTyConRhs
+ -> Kind -- ^ Kind of the RHS
+ -> TyConParent
+ -> Maybe (TyCon, [Type]) -- ^ family instance if applicable
+ -> TcRnIf m n TyCon
+buildSynTyCon tc_name tvs rhs rhs_kind parent mb_family
+ | Just fam_inst_info <- mb_family
+ = ASSERT( isNoParent parent )
+ fixM $ \ tycon_rec -> do
+ { fam_parent <- mkFamInstParentInfo tc_name tvs fam_inst_info tycon_rec
+ ; return (mkSynTyCon tc_name kind tvs rhs fam_parent) }
+
+ | otherwise
+ = return (mkSynTyCon tc_name kind tvs rhs parent)
where
- kind = mkArrowKinds (map tyVarKind tvs) rhs_ki
-buildSynTyCon name tvs rhs@(SynonymTyCon rhs_ty)
- = mkSynTyCon name kind tvs rhs
- where
- kind = mkArrowKinds (map tyVarKind tvs) (typeKind rhs_ty)
-
+ kind = mkArrowKinds (map tyVarKind tvs) rhs_kind
------------------------------------------------------
buildAlgTyCon :: Name -> [TyVar]
- -> ThetaType -- Stupid theta
+ -> ThetaType -- ^ Stupid theta
-> AlgTyConRhs
-> RecFlag
- -> Bool -- True <=> want generics functions
- -> Bool -- True <=> was declared in GADT syntax
- -> Maybe (TyCon, [Type],
- Int) -- Just (family, tys, index)
- -- <=> instance of `family' at `tys'
+ -> Bool -- ^ True <=> want generics functions
+ -> Bool -- ^ True <=> was declared in GADT syntax
+ -> TyConParent
+ -> Maybe (TyCon, [Type]) -- ^ family instance if applicable
-> TcRnIf m n TyCon
buildAlgTyCon tc_name tvs stupid_theta rhs is_rec want_generics gadt_syn
- mb_family
- = do { -- We need to tie a knot as the coercion of a data instance depends
- -- on the instance representation tycon and vice versa.
- ; tycon <- fixM (\ tycon_rec -> do
- { (final_name, parent) <- maybeComputeFamilyInfo mb_family tycon_rec
- ; let { tycon = mkAlgTyCon final_name kind tvs stupid_theta rhs
- fields parent is_rec want_generics gadt_syn
- ; kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
- ; fields = mkTyConSelIds tycon rhs
- }
- ; return tycon
- })
- ; return tycon
- }
+ parent mb_family
+ | Just fam_inst_info <- mb_family
+ = -- We need to tie a knot as the coercion of a data instance depends
+ -- on the instance representation tycon and vice versa.
+ ASSERT( isNoParent parent )
+ fixM $ \ tycon_rec -> do
+ { fam_parent <- mkFamInstParentInfo tc_name tvs fam_inst_info tycon_rec
+ ; return (mkAlgTyCon tc_name kind tvs stupid_theta rhs
+ fam_parent is_rec want_generics gadt_syn) }
+
+ | otherwise
+ = return (mkAlgTyCon tc_name kind tvs stupid_theta rhs
+ parent is_rec want_generics gadt_syn)
where
- -- If a family tycon with instance types is given, the current tycon is an
- -- instance of that family and we have to perform three extra tasks:
- --
- -- (1) The instance tycon (representing the family at a particular type
- -- instance) need to get a new, derived name - we may not reuse the
- -- family name.
- -- (2) Create a coercion that identifies the family instance type and the
- -- representation type from Step (1); ie, it is of the form
- -- `Co tvs :: F ts :=: R tvs', where `Co' is the name of the coercion,
- -- `F' the family tycon and `R' the (derived) representation tycon.
- -- (3) Produce a `AlgTyConParent' value containing the parent and coercion
- -- information.
- --
- maybeComputeFamilyInfo Nothing rep_tycon =
- return (tc_name, NoParentTyCon)
- maybeComputeFamilyInfo (Just (family, instTys, index)) rep_tycon =
- do { -- (1) New, derived name for the instance tycon
- ; final_name <- newImplicitBinder tc_name (mkInstTyTcOcc index)
-
- -- (2) Create the coercion.
- ; co_tycon_name <- newImplicitBinder tc_name (mkInstTyCoOcc index)
- ; let co_tycon = mkDataInstCoercion co_tycon_name tvs
- family instTys rep_tycon
-
- -- (3) Produce parent information.
- ; return (final_name, FamilyTyCon family instTys co_tycon index)
- }
+ kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
+
+-- | If a family tycon with instance types is given, the current tycon is an
+-- instance of that family and we need to
+--
+-- (1) create a coercion that identifies the family instance type and the
+-- representation type from Step (1); ie, it is of the form
+-- `Co tvs :: F ts ~ R tvs', where `Co' is the name of the coercion,
+-- `F' the family tycon and `R' the (derived) representation tycon,
+-- and
+-- (2) produce a `TyConParent' value containing the parent and coercion
+-- information.
+--
+mkFamInstParentInfo :: Name -> [TyVar]
+ -> (TyCon, [Type])
+ -> TyCon
+ -> TcRnIf m n TyConParent
+mkFamInstParentInfo tc_name tvs (family, instTys) rep_tycon
+ = do { -- Create the coercion
+ ; co_tycon_name <- newImplicitBinder tc_name mkInstTyCoOcc
+ ; let co_tycon = mkFamInstCoercion co_tycon_name tvs
+ family instTys rep_tycon
+ ; return $ FamInstTyCon family instTys co_tycon }
-
------------------------------------------------------
mkAbstractTyConRhs :: AlgTyConRhs
mkAbstractTyConRhs = AbstractTyCon
-mkOpenDataTyConRhs :: AlgTyConRhs
-mkOpenDataTyConRhs = OpenDataTyCon
-
-mkOpenNewTyConRhs :: AlgTyConRhs
-mkOpenNewTyConRhs = OpenNewTyCon
-
mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
mkDataTyConRhs cons
- = DataTyCon { data_cons = cons, is_enum = all isNullarySrcDataCon cons }
+ = DataTyCon {
+ data_cons = cons,
+ is_enum = not (null cons) && all is_enum_con cons
+ -- See Note [Enumeration types] in TyCon
+ }
+ where
+ is_enum_con con
+ | (_tvs, theta, arg_tys, _res) <- dataConSig con
+ = null theta && null arg_tys
+
mkNewTyConRhs :: Name -> TyCon -> DataCon -> TcRnIf m n AlgTyConRhs
--- Monadic because it makes a Name for the coercion TyCon
--- We pass the Name of the parent TyCon, as well as the TyCon itself,
--- because the latter is part of a knot, whereas the former is not.
+-- ^ Monadic because it makes a Name for the coercion TyCon
+-- We pass the Name of the parent TyCon, as well as the TyCon itself,
+-- because the latter is part of a knot, whereas the former is not.
mkNewTyConRhs tycon_name tycon con
= do { co_tycon_name <- newImplicitBinder tycon_name mkNewTyCoOcc
- ; let co_tycon = mkNewTypeCoercion co_tycon_name tycon tvs rhs_ty
- cocon_maybe
- | all_coercions || isRecursiveTyCon tycon
- = Just co_tycon
- | otherwise
- = Nothing
- ; return (NewTyCon { data_con = con,
- nt_co = cocon_maybe,
+ ; let co_tycon = mkNewTypeCoercion co_tycon_name tycon etad_tvs etad_rhs
+ cocon_maybe | all_coercions || isRecursiveTyCon tycon
+ = Just co_tycon
+ | otherwise
+ = Nothing
+ ; traceIf (text "mkNewTyConRhs" <+> ppr cocon_maybe)
+ ; return (NewTyCon { data_con = con,
+ nt_rhs = rhs_ty,
+ nt_etad_rhs = (etad_tvs, etad_rhs),
+ nt_co = cocon_maybe } ) }
-- Coreview looks through newtypes with a Nothing
-- for nt_co, or uses explicit coercions otherwise
- nt_rhs = rhs_ty,
- nt_etad_rhs = eta_reduce tvs rhs_ty,
- nt_rep = mkNewTyConRep tycon rhs_ty }) }
where
- -- if all_coercions is True then we use coercions for all newtypes
+ -- If all_coercions is True then we use coercions for all newtypes
-- otherwise we use coercions for recursive newtypes and look through
-- non-recursive newtypes
all_coercions = True
tvs = tyConTyVars tycon
- rhs_ty = head (dataConInstOrigArgTys con (mkTyVarTys tvs))
+ inst_con_ty = applyTys (dataConUserType con) (mkTyVarTys tvs)
+ rhs_ty = ASSERT( isFunTy inst_con_ty ) funArgTy inst_con_ty
-- Instantiate the data con with the
-- type variables from the tycon
-
- eta_reduce [] ty = ([], ty)
- eta_reduce (a:as) ty | null as',
- Just (fun, arg) <- splitAppTy_maybe ty',
+ -- NB: a newtype DataCon has a type that must look like
+ -- forall tvs. <arg-ty> -> T tvs
+ -- Note that we *can't* use dataConInstOrigArgTys here because
+ -- the newtype arising from class Foo a => Bar a where {}
+ -- has a single argument (Foo a) that is a *type class*, so
+ -- dataConInstOrigArgTys returns [].
+
+ etad_tvs :: [TyVar] -- Matched lazily, so that mkNewTypeCoercion can
+ etad_rhs :: Type -- return a TyCon without pulling on rhs_ty
+ -- See Note [Tricky iface loop] in LoadIface
+ (etad_tvs, etad_rhs) = eta_reduce (reverse tvs) rhs_ty
+
+ eta_reduce :: [TyVar] -- Reversed
+ -> Type -- Rhs type
+ -> ([TyVar], Type) -- Eta-reduced version (tyvars in normal order)
+ eta_reduce (a:as) ty | Just (fun, arg) <- splitAppTy_maybe ty,
Just tv <- getTyVar_maybe arg,
tv == a,
not (a `elemVarSet` tyVarsOfType fun)
- = ([], fun) -- Successful eta reduction
- | otherwise
- = (a:as', ty')
- where
- (as', ty') = eta_reduce as ty
+ = eta_reduce as fun
+ eta_reduce tvs ty = (reverse tvs, ty)
-mkNewTyConRep :: TyCon -- The original type constructor
- -> Type -- The arg type of its constructor
- -> Type -- Chosen representation type
--- The "representation type" is guaranteed not to be another newtype
--- at the outermost level; but it might have newtypes in type arguments
-
--- Find the representation type for this newtype TyCon
--- Remember that the representation type is the *ultimate* representation
--- type, looking through other newtypes.
---
--- splitTyConApp_maybe no longer looks through newtypes, so we must
--- deal explicitly with this case
---
--- The trick is to to deal correctly with recursive newtypes
--- such as newtype T = MkT T
-
-mkNewTyConRep tc rhs_ty
- | null (tyConDataCons tc) = unitTy
- -- External Core programs can have newtypes with no data constructors
- | otherwise = go [tc] rhs_ty
- where
- -- Invariant: tcs have been seen before
- go tcs rep_ty
- = case splitTyConApp_maybe rep_ty of
- Just (tc, tys)
- | tc `elem` tcs -> unitTy -- Recursive loop
- | isNewTyCon tc ->
- if isRecursiveTyCon tc then
- go (tc:tcs) (substTyWith tvs tys rhs_ty)
- else
- substTyWith tvs tys rhs_ty
- where
- (tvs, rhs_ty) = newTyConRhs tc
-
- other -> rep_ty
------------------------------------------------------
buildDataCon :: Name -> Bool
- -> [StrictnessMark]
+ -> [HsBang]
-> [Name] -- Field labels
-> [TyVar] -> [TyVar] -- Univ and ext
-> [(TyVar,Type)] -- Equality spec
-> ThetaType -- Does not include the "stupid theta"
-- or the GADT equalities
- -> [Type] -> TyCon
+ -> [Type] -> Type -- Argument and result types
+ -> TyCon -- Rep tycon
-> TcRnIf m n DataCon
-- A wrapper for DataCon.mkDataCon that
-- a) makes the worker Id
-- b) makes the wrapper Id if necessary, including
-- allocating its unique (hence monadic)
buildDataCon src_name declared_infix arg_stricts field_lbls
- univ_tvs ex_tvs eq_spec ctxt arg_tys tycon
+ univ_tvs ex_tvs eq_spec ctxt arg_tys res_ty rep_tycon
= do { wrap_name <- newImplicitBinder src_name mkDataConWrapperOcc
; work_name <- newImplicitBinder src_name mkDataConWorkerOcc
-- This last one takes the name of the data constructor in the source
-- space, and puts it into the VarName name space
; let
- stupid_ctxt = mkDataConStupidTheta tycon arg_tys univ_tvs
+ stupid_ctxt = mkDataConStupidTheta rep_tycon arg_tys univ_tvs
data_con = mkDataCon src_name declared_infix
arg_stricts field_lbls
univ_tvs ex_tvs eq_spec ctxt
- arg_tys tycon
+ arg_tys res_ty rep_tycon
stupid_ctxt dc_ids
dc_ids = mkDataConIds wrap_name work_name data_con
- ; returnM data_con }
+ ; return data_con }
-- The stupid context for a data constructor should be limited to
-- the type variables mentioned in the arg_tys
-- ToDo: Or functionally dependent on?
-- This whole stupid theta thing is, well, stupid.
+mkDataConStupidTheta :: TyCon -> [Type] -> [TyVar] -> [PredType]
mkDataConStupidTheta tycon arg_tys univ_tvs
| null stupid_theta = [] -- The common case
| otherwise = filter in_arg_tys stupid_theta
arg_tyvars = tyVarsOfTypes arg_tys
in_arg_tys pred = not $ isEmptyVarSet $
tyVarsOfPred pred `intersectVarSet` arg_tyvars
-
-------------------------------------------------------
-mkTyConSelIds :: TyCon -> AlgTyConRhs -> [Id]
-mkTyConSelIds tycon rhs
- = [ mkRecordSelId tycon fld
- | fld <- nub (concatMap dataConFieldLabels (visibleDataCons rhs)) ]
- -- We'll check later that fields with the same name
- -- from different constructors have the same type.
\end{code}
------------------------------------------------------
\begin{code}
-buildClass :: Name -> [TyVar] -> ThetaType
- -> [FunDep TyVar] -- Functional dependencies
- -> [TyThing] -- Associated types
- -> [(Name, DefMeth, Type)] -- Method info
- -> RecFlag -- Info for type constructor
+type TcMethInfo = (Name, DefMethSpec, Type) -- A temporary intermediate, to communicate
+ -- between tcClassSigs and buildClass
+
+buildClass :: Bool -- True <=> do not include unfoldings
+ -- on dict selectors
+ -- Used when importing a class without -O
+ -> Name -> [TyVar] -> ThetaType
+ -> [FunDep TyVar] -- Functional dependencies
+ -> [TyThing] -- Associated types
+ -> [TcMethInfo] -- Method info
+ -> RecFlag -- Info for type constructor
-> TcRnIf m n Class
-buildClass class_name tvs sc_theta fds ats sig_stuff tc_isrec
- = do { tycon_name <- newImplicitBinder class_name mkClassTyConOcc
+buildClass no_unf class_name tvs sc_theta fds ats sig_stuff tc_isrec
+ = do { traceIf (text "buildClass")
+ ; tycon_name <- newImplicitBinder class_name mkClassTyConOcc
; datacon_name <- newImplicitBinder class_name mkClassDataConOcc
-- The class name is the 'parent' for this datacon, not its tycon,
-- because one should import the class to get the binding for
-- the datacon
- ; sc_sel_names <- mapM (newImplicitBinder class_name . mkSuperDictSelOcc)
- [1..length sc_theta]
- -- We number off the superclass selectors, 1, 2, 3 etc so that we
- -- can construct names for the selectors. Thus
- -- class (C a, C b) => D a b where ...
- -- gives superclass selectors
- -- D_sc1, D_sc2
- -- (We used to call them D_C, but now we can have two different
- -- superclasses both called C!)
; fixM (\ rec_clas -> do { -- Only name generation inside loop
- let { rec_tycon = classTyCon rec_clas
- ; op_tys = [ty | (_,_,ty) <- sig_stuff]
- ; sc_tys = mkPredTys sc_theta
- ; dict_component_tys = sc_tys ++ op_tys
- ; sc_sel_ids = [mkDictSelId sc_name rec_clas | sc_name <- sc_sel_names]
- ; op_items = [ (mkDictSelId op_name rec_clas, dm_info)
- | (op_name, dm_info, _) <- sig_stuff ] }
+ ; op_items <- mapM (mk_op_item rec_clas) sig_stuff
-- Build the selector id and default method id
+ ; let (eq_theta, dict_theta) = partition isEqPred sc_theta
+
+ -- We only make selectors for the *value* superclasses,
+ -- not equality predicates
+ ; sc_sel_names <- mapM (newImplicitBinder class_name . mkSuperDictSelOcc)
+ [1..length dict_theta]
+ ; let sc_sel_ids = [ mkDictSelId no_unf sc_name rec_clas
+ | sc_name <- sc_sel_names]
+ -- We number off the Dict superclass selectors, 1, 2, 3 etc so that we
+ -- can construct names for the selectors. Thus
+ -- class (C a, C b) => D a b where ...
+ -- gives superclass selectors
+ -- D_sc1, D_sc2
+ -- (We used to call them D_C, but now we can have two different
+ -- superclasses both called C!)
+
+ ; let use_newtype = null eq_theta && (length dict_theta + length sig_stuff == 1)
+ -- Use a newtype if the data constructor has
+ -- (a) exactly one value field
+ -- (b) no existential or equality-predicate fields
+ -- i.e. exactly one operation or superclass taken together
+ -- See note [Class newtypes and equality predicates]
+
+ -- We play a bit fast and loose by treating the dictionary
+ -- superclasses as ordinary arguments. That means that in
+ -- the case of
+ -- class C a => D a
+ -- we don't get a newtype with no arguments!
+ args = sc_sel_names ++ op_names
+ op_tys = [ty | (_,_,ty) <- sig_stuff]
+ op_names = [op | (op,_,_) <- sig_stuff]
+ arg_tys = map mkPredTy dict_theta ++ op_tys
+ rec_tycon = classTyCon rec_clas
+
; dict_con <- buildDataCon datacon_name
False -- Not declared infix
- (map (const NotMarkedStrict) dict_component_tys)
- [{- No labelled fields -}]
+ (map (const HsNoBang) args)
+ [{- No fields -}]
tvs [{- no existentials -}]
- [{- No equalities -}] [{-No context-}]
- dict_component_tys
+ [{- No GADT equalities -}]
+ eq_theta
+ arg_tys
+ (mkTyConApp rec_tycon (mkTyVarTys tvs))
rec_tycon
- ; rhs <- case dict_component_tys of
- [rep_ty] -> mkNewTyConRhs tycon_name rec_tycon dict_con
- other -> return (mkDataTyConRhs [dict_con])
+ ; rhs <- if use_newtype
+ then mkNewTyConRhs tycon_name rec_tycon dict_con
+ else return (mkDataTyConRhs [dict_con])
; let { clas_kind = mkArrowKinds (map tyVarKind tvs) liftedTypeKind
; tycon = mkClassTyCon tycon_name clas_kind tvs
- rhs rec_clas tc_isrec
+ rhs rec_clas tc_isrec
-- A class can be recursive, and in the case of newtypes
-- this matters. For example
-- class C a where { op :: C b => a -> b -> Int }
-- newtype like a synonym, but that will lead to an infinite
-- type]
; atTyCons = [tycon | ATyCon tycon <- ats]
+
+ ; result = mkClass class_name tvs fds
+ (eq_theta ++ dict_theta) -- Equalities first
+ (length eq_theta) -- Number of equalities
+ sc_sel_ids atTyCons
+ op_items tycon
}
- ; return (mkClass class_name tvs fds
- sc_theta sc_sel_ids atTyCons op_items
- tycon)
+ ; traceIf (text "buildClass" <+> ppr tycon)
+ ; return result
})}
+ where
+ mk_op_item :: Class -> TcMethInfo -> TcRnIf n m ClassOpItem
+ mk_op_item rec_clas (op_name, dm_spec, _)
+ = do { dm_info <- case dm_spec of
+ NoDM -> return NoDefMeth
+ GenericDM -> return GenDefMeth
+ VanillaDM -> do { dm_name <- newImplicitBinder op_name mkDefaultMethodOcc
+ ; return (DefMeth dm_name) }
+ ; return (mkDictSelId no_unf op_name rec_clas, dm_info) }
\end{code}
+Note [Class newtypes and equality predicates]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Consider
+ class (a ~ F b) => C a b where
+ op :: a -> b
+
+We cannot represent this by a newtype, even though it's not
+existential, and there's only one value field, because we do
+capture an equality predicate:
+
+ data C a b where
+ MkC :: forall a b. (a ~ F b) => (a->b) -> C a b
+
+We need to access this equality predicate when we get passes a C
+dictionary. See Trac #2238