X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcHsType.lhs;h=dabd17f764785a70252e56c093ee83b5021aac5a;hb=3f1b316d7035c55cd712cd39a9981339bcef2e8c;hp=3d365ab3d670503ea916e51d8c3bfb22f7b74ad2;hpb=ab22f4e6456820c1b5169d75f5975a94e61f54ce;p=ghc-hetmet.git

diff --git a/compiler/typecheck/TcHsType.lhs b/compiler/typecheck/TcHsType.lhs
index 3d365ab..dabd17f 100644
--- a/compiler/typecheck/TcHsType.lhs
+++ b/compiler/typecheck/TcHsType.lhs
@@ -5,8 +5,16 @@
 \section[TcMonoType]{Typechecking user-specified @MonoTypes@}
 
 \begin{code}
+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
 module TcHsType (
-	tcHsSigType, tcHsDeriv,
+	tcHsSigType, tcHsDeriv, 
+	tcHsInstHead, tcHsQuantifiedType,
 	UserTypeCtxt(..), 
 
 		-- Kind checking
@@ -143,6 +151,24 @@ tcHsSigType ctxt hs_ty
 	; checkValidType ctxt ty	
 	; returnM ty }
 
+tcHsInstHead :: LHsType Name -> TcM ([TyVar], ThetaType, Type)
+-- Typecheck an instance head.  We can't use 
+-- tcHsSigType, because it's not a valid user type.
+tcHsInstHead hs_ty
+  = do	{ kinded_ty <- kcHsSigType hs_ty
+	; poly_ty   <- tcHsKindedType kinded_ty
+	; return (tcSplitSigmaTy poly_ty) }
+
+tcHsQuantifiedType :: [LHsTyVarBndr Name] -> LHsType Name -> TcM ([TyVar], Type)
+-- Behave very like type-checking (HsForAllTy sig_tvs hs_ty),
+-- except that we want to keep the tvs separate
+tcHsQuantifiedType tv_names hs_ty
+  = kcHsTyVars tv_names $ \ tv_names' ->
+    do	{ kc_ty <- kcHsSigType hs_ty
+    	; tcTyVarBndrs tv_names' $ \ tvs ->
+    do	{ ty <- dsHsType kc_ty
+    	; return (tvs, ty) } }
+
 -- Used for the deriving(...) items
 tcHsDeriv :: LHsType Name -> TcM ([TyVar], Class, [Type])
 tcHsDeriv = addLocM (tc_hs_deriv [])
@@ -315,8 +341,12 @@ kc_hs_type ty@(HsAppTy ty1 ty2)
     split (L _ (HsAppTy f a)) as = split f (a:as)
     split f       	      as = (f,as)
     mk_app fun arg = HsAppTy (noLoc fun) arg	-- Add noLocs for inner nodes of
-						-- the application; they are never used
-    
+						-- the application; they are
+						-- never used 
+
+kc_hs_type ty@(HsPredTy (HsEqualP _ _))
+  = wrongEqualityErr
+
 kc_hs_type (HsPredTy pred)
   = kcHsPred pred		`thenM` \ pred' ->
     returnM (HsPredTy pred', liftedTypeKind)
@@ -388,13 +418,22 @@ kc_pred :: HsPred Name -> TcM (HsPred Name, TcKind)
 	-- Does *not* check for a saturated
 	-- application (reason: used from TcDeriv)
 kc_pred pred@(HsIParam name ty)
-  = kcHsType ty		`thenM` \ (ty', kind) ->
-    returnM (HsIParam name ty', kind)
-
+  = do { (ty', kind) <- kcHsType ty
+       ; returnM (HsIParam name ty', kind)
+       }
 kc_pred pred@(HsClassP cls tys)
-  = kcClass cls			`thenM` \ kind ->
-    kcApps kind (ppr cls) tys	`thenM` \ (tys', res_kind) ->
-    returnM (HsClassP cls tys', res_kind)
+  = do { kind <- kcClass cls
+       ; (tys', res_kind) <- kcApps kind (ppr cls) tys
+       ; returnM (HsClassP cls tys', res_kind)
+       }
+kc_pred pred@(HsEqualP ty1 ty2)
+  = do { (ty1', kind1) <- kcHsType ty1
+--       ; checkExpectedKind ty1 kind1 liftedTypeKind
+       ; (ty2', kind2) <- kcHsType ty2
+--       ; checkExpectedKind ty2 kind2 liftedTypeKind
+       ; checkExpectedKind ty2 kind2 kind1
+       ; returnM (HsEqualP ty1' ty2', liftedTypeKind)
+       }
 
 ---------------------------
 kcTyVar :: Name -> TcM TcKind
@@ -498,6 +537,9 @@ ds_type full_ty@(HsForAllTy exp tv_names ctxt ty)
 
 ds_type (HsSpliceTy {}) = panic "ds_type: HsSpliceTy"
 
+ds_type (HsDocTy ty _)  -- Remove the doc comment
+  = dsHsType ty
+
 dsHsTypes arg_tys = mappM dsHsType arg_tys
 \end{code}
 
@@ -534,13 +576,19 @@ dsHsLPred :: LHsPred Name -> TcM PredType
 dsHsLPred pred = dsHsPred (unLoc pred)
 
 dsHsPred pred@(HsClassP class_name tys)
-  = dsHsTypes tys			`thenM` \ arg_tys ->
-    tcLookupClass class_name		`thenM` \ clas ->
-    returnM (ClassP clas arg_tys)
-
+  = do { arg_tys <- dsHsTypes tys
+       ; clas <- tcLookupClass class_name
+       ; returnM (ClassP clas arg_tys)
+       }
+dsHsPred pred@(HsEqualP ty1 ty2)
+  = do { arg_ty1 <- dsHsType ty1
+       ; arg_ty2 <- dsHsType ty2
+       ; returnM (EqPred arg_ty1 arg_ty2)
+       }
 dsHsPred (HsIParam name ty)
-  = dsHsType ty					`thenM` \ arg_ty ->
-    returnM (IParam name arg_ty)
+  = do { arg_ty <- dsHsType ty
+       ; returnM (IParam name arg_ty)
+       }
 \end{code}
 
 GADT constructor signatures
@@ -612,7 +660,7 @@ tcTyVarBndrs bndrs thing_inside
   where
     zonk (KindedTyVar name kind) = do { kind' <- zonkTcKindToKind kind
 				      ; return (mkTyVar name kind') }
-    zonk (UserTyVar name) = pprTrace "Un-kinded tyvar" (ppr name) $
+    zonk (UserTyVar name) = WARN( True, ptext SLIT("Un-kinded tyvar") <+> ppr name )
 			    return (mkTyVar name liftedTypeKind)
 
 -----------------------------------
@@ -627,9 +675,8 @@ tcDataKindSig (Just kind)
   = do	{ checkTc (isLiftedTypeKind res_kind) (badKindSig kind)
 	; span <- getSrcSpanM
 	; us   <- newUniqueSupply 
-	; let loc   = srcSpanStart span
-	      uniqs = uniqsFromSupply us
-	; return [ mk_tv loc uniq str kind 
+	; let uniqs = uniqsFromSupply us
+	; return [ mk_tv span uniq str kind 
 		 | ((kind, str), uniq) <- arg_kinds `zip` names `zip` uniqs ] }
   where
     (arg_kinds, res_kind) = splitKindFunTys kind
@@ -708,16 +755,10 @@ tcHsPatSigType ctxt hs_ty
 			| n <- nameSetToList (extractHsTyVars hs_ty),
 			  not (in_scope n) ]
 
-	-- Behave very like type-checking (HsForAllTy sig_tvs hs_ty),
-	-- except that we want to keep the tvs separate
-	; (kinded_tvs, kinded_ty) <- kcHsTyVars sig_tvs $ \ kinded_tvs -> do
-				    { kinded_ty <- kcTypeType hs_ty
-				    ; return (kinded_tvs, kinded_ty) }
-	; tcTyVarBndrs kinded_tvs $ \ tyvars -> do
-	{ sig_ty <- dsHsType kinded_ty
+	; (tyvars, sig_ty) <- tcHsQuantifiedType sig_tvs hs_ty
 	; checkValidType ctxt sig_ty 
 	; return (tyvars, sig_ty)
-      } }
+      }
 
 tcPatSig :: UserTypeCtxt
 	 -> LHsType Name
@@ -800,7 +841,6 @@ pprHsSigCtxt ctxt hs_ty = vcat [ ptext SLIT("In") <+> pprUserTypeCtxt ctxt <> co
     pp_sig (FunSigCtxt n)  = pp_n_colon n
     pp_sig (ConArgCtxt n)  = pp_n_colon n
     pp_sig (ForSigCtxt n)  = pp_n_colon n
-    pp_sig (RuleSigCtxt n) = pp_n_colon n
     pp_sig other	   = ppr (unLoc hs_ty)
 
     pp_n_colon n = ppr n <+> dcolon <+> ppr (unLoc hs_ty)
@@ -820,5 +860,8 @@ dupInScope n n' ty
   = hang (ptext SLIT("The scoped type variables") <+> quotes (ppr n) <+> ptext SLIT("and") <+> quotes (ppr n'))
        2 (vcat [ptext SLIT("are bound to the same type (variable)"),
 		ptext SLIT("Distinct scoped type variables must be distinct")])
+
+wrongEqualityErr
+  = failWithTc (text "Equality predicate used as a type")
 \end{code}