-
+%
+% (c) The University of Glasgow 2006
% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
%
\section[TcMonoType]{Typechecking user-specified @MonoTypes@}
#include "HsVersions.h"
-import HsSyn ( HsType(..), LHsType, HsTyVarBndr(..), LHsTyVarBndr,
- LHsContext, HsPred(..), LHsPred, HsExplicitForAll(..) )
-import RnHsSyn ( extractHsTyVars )
+import HsSyn
+import RnHsSyn
import TcRnMonad
-import TcEnv ( tcExtendTyVarEnv, tcExtendKindEnvTvs,
- tcLookup, tcLookupClass, tcLookupTyCon,
- TyThing(..), getInLocalScope, getScopedTyVarBinds,
- wrongThingErr
- )
-import TcMType ( newKindVar,
- zonkTcKindToKind,
- tcInstBoxyTyVar, readFilledBox,
- checkValidType
- )
-import TcUnify ( boxyUnify, unifyFunKind, checkExpectedKind )
-import TcIface ( checkWiredInTyCon )
-import TcType ( Type, PredType(..), ThetaType, BoxySigmaType,
- TcType, TcKind, isRigidTy,
- UserTypeCtxt(..), pprUserTypeCtxt,
- substTyWith, mkTyVarTys, tcEqType,
- tcIsTyVarTy, mkFunTy, mkSigmaTy, mkPredTy,
- mkTyConApp, mkAppTys, typeKind )
-import Kind ( Kind, isLiftedTypeKind, liftedTypeKind, ubxTupleKind,
- openTypeKind, argTypeKind, splitKindFunTys )
-import Var ( TyVar, mkTyVar, tyVarName )
-import TyCon ( TyCon, tyConKind )
-import Class ( Class, classTyCon )
-import Name ( Name, mkInternalName )
-import OccName ( mkOccName, tvName )
+import TcEnv
+import TcMType
+import TcUnify
+import TcIface
+import TcType
+import {- Kind parts of -} Type
+import Var
+import TyCon
+import Class
+import Name
+import OccName
import NameSet
-import PrelNames ( genUnitTyConName )
-import TysWiredIn ( mkListTy, listTyCon, mkPArrTy, parrTyCon, tupleTyCon )
-import BasicTypes ( Boxity(..) )
-import SrcLoc ( Located(..), unLoc, noLoc, getLoc, srcSpanStart )
-import UniqSupply ( uniqsFromSupply )
+import PrelNames
+import TysWiredIn
+import BasicTypes
+import SrcLoc
+import UniqSupply
import Outputable
\end{code}
; return (L span ty') }
where
-- Wrap a context around only if we want to show that contexts.
+ add_ctxt (HsPredTy p) thing = thing
-- Omit invisble ones and ones user's won't grok (HsPred p).
- add_ctxt (HsPredTy p) thing = thing
- add_ctxt (HsForAllTy Implicit tvs (L _ []) (L _ ty)) thing = add_ctxt ty thing
- add_ctxt other_ty thing = addErrCtxt (typeCtxt ty) thing
+ add_ctxt (HsForAllTy _ _ (L _ []) _) thing = thing
+ -- Omit wrapping if the theta-part is empty
+ -- Reason: the recursive call to kcLiftedType, in the ForAllTy
+ -- case of kc_hs_type, will do the wrapping instead
+ -- and we don't want to duplicate
+ add_ctxt other_ty thing = addErrCtxt (typeCtxt other_ty) thing
-- We infer the kind of the type, and then complain if it's
-- not right. But we don't want to complain about
kc_hs_type (HsForAllTy exp tv_names context ty)
= kcHsTyVars tv_names $ \ tv_names' ->
- kcHsContext context `thenM` \ ctxt' ->
- kcLiftedType ty `thenM` \ ty' ->
- -- The body of a forall is usually a type, but in principle
- -- there's no reason to prohibit *unlifted* types.
- -- In fact, GHC can itself construct a function with an
- -- unboxed tuple inside a for-all (via CPR analyis; see
- -- typecheck/should_compile/tc170)
- --
- -- Still, that's only for internal interfaces, which aren't
- -- kind-checked, so we only allow liftedTypeKind here
- returnM (HsForAllTy exp tv_names' ctxt' ty', liftedTypeKind)
+ do { ctxt' <- kcHsContext context
+ ; ty' <- kcLiftedType ty
+ -- The body of a forall is usually a type, but in principle
+ -- there's no reason to prohibit *unlifted* types.
+ -- In fact, GHC can itself construct a function with an
+ -- unboxed tuple inside a for-all (via CPR analyis; see
+ -- typecheck/should_compile/tc170)
+ --
+ -- Still, that's only for internal interfaces, which aren't
+ -- kind-checked, so we only allow liftedTypeKind here
+
+ ; return (HsForAllTy exp tv_names' ctxt' ty', liftedTypeKind) }
kc_hs_type (HsBangTy b ty)
= do { (ty', kind) <- kcHsType ty
kc_hs_type ty@(HsSpliceTy _)
= failWithTc (ptext SLIT("Unexpected type splice:") <+> ppr ty)
+-- remove the doc nodes here, no need to worry about the location since
+-- its the same for a doc node and it's child type node
+kc_hs_type (HsDocTy ty _)
+ = kc_hs_type (unLoc ty)
---------------------------
kcApps :: TcKind -- Function kind
dsHsType ty `thenM` \ tau ->
returnM (mkSigmaTy tyvars theta tau)
+ds_type (HsSpliceTy {}) = panic "ds_type: HsSpliceTy"
+
dsHsTypes arg_tys = mappM dsHsType arg_tys
\end{code}
-- GADT decls can have a (perhaps partial) kind signature
-- e.g. data T :: * -> * -> * where ...
-- This function makes up suitable (kinded) type variables for
--- the argument kinds, and checks that the result kind is indeed *
+-- the argument kinds, and checks that the result kind is indeed *.
+-- We use it also to make up argument type variables for for data instances.
tcDataKindSig Nothing = return []
tcDataKindSig (Just kind)
= do { checkTc (isLiftedTypeKind res_kind) (badKindSig kind)