X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypecheck%2FTcBinds.lhs;h=e3bd6575fd0c63adb43af5936259ef6bf1d7101e;hb=ade2870f9be663775e9fc62cf43edf967e268199;hp=aab8f012ac5eaf68857675df928ef340a0330ea6;hpb=1d1c3c727617630beacacaf33022e1daba06a0bb;p=ghc-hetmet.git

diff --git a/compiler/typecheck/TcBinds.lhs b/compiler/typecheck/TcBinds.lhs
index aab8f01..e3bd657 100644
--- a/compiler/typecheck/TcBinds.lhs
+++ b/compiler/typecheck/TcBinds.lhs
@@ -56,6 +56,8 @@ import List
 import Util
 import BasicTypes
 import Outputable
+
+import Control.Monad
 \end{code}
 
 
@@ -141,11 +143,11 @@ tcLocalBinds (HsIPBinds (IPBinds ip_binds _)) thing_inside
 	-- I wonder if we should do these one at at time
 	-- Consider	?x = 4
 	--		?y = ?x + 1
-    tc_ip_bind (IPBind ip expr)
-      = newFlexiTyVarTy argTypeKind		`thenM` \ ty ->
-  	newIPDict (IPBindOrigin ip) ip ty	`thenM` \ (ip', ip_inst) ->
-  	tcMonoExpr expr ty			`thenM` \ expr' ->
-  	returnM (ip_inst, (IPBind ip' expr'))
+    tc_ip_bind (IPBind ip expr) = do
+        ty <- newFlexiTyVarTy argTypeKind
+        (ip', ip_inst) <- newIPDict (IPBindOrigin ip) ip ty
+        expr' <- tcMonoExpr expr ty
+        return (ip_inst, (IPBind ip' expr'))
 
 ------------------------
 tcValBinds :: TopLevelFlag 
@@ -426,10 +428,8 @@ tcSpecPrag :: TcId -> LHsType Name -> InlineSpec -> TcM Prag
 tcSpecPrag poly_id hs_ty inl
   = do	{ let name = idName poly_id
 	; spec_ty <- tcHsSigType (FunSigCtxt name) hs_ty
-	; (co_fn, lie) <- getLIE (tcSubExp (SpecPragOrigin name) (idType poly_id) spec_ty)
-	; extendLIEs lie
-	; let const_dicts = map instToId lie
-	; return (SpecPrag (mkHsWrap co_fn (HsVar poly_id)) spec_ty const_dicts inl) }
+	; co_fn <- tcSubExp (SpecPragOrigin name) (idType poly_id) spec_ty
+	; return (SpecPrag (mkHsWrap co_fn (HsVar poly_id)) spec_ty inl) }
 	-- Most of the work of specialisation is done by 
 	-- the desugarer, guided by the SpecPrag
   
@@ -548,14 +548,17 @@ tcMonoBinds [L b_loc (FunBind { fun_id = L nm_loc name, fun_infix = inf,
 	-- we can (a) use genuine, rigid skolem constants for the type variables
 	--	  (b) bring (rigid) scoped type variables into scope
     setSrcSpan b_loc  	$
-    do	{ tc_sig <- tcInstSig True name scoped_tvs
+    do	{ tc_sig <- tcInstSig True name
 	; mono_name <- newLocalName name
 	; let mono_ty = sig_tau tc_sig
 	      mono_id = mkLocalId mono_name mono_ty
 	      rhs_tvs = [ (name, mkTyVarTy tv)
-			| (name, tv) <- sig_scoped tc_sig `zip` sig_tvs tc_sig ]
+		        | (name, tv) <- scoped_tvs `zip` sig_tvs tc_sig ]
+			-- See Note [More instantiated than scoped]
+			-- Note that the scoped_tvs and the (sig_tvs sig) 
+			-- may have different Names. That's quite ok.
 
-	; (co_fn, matches') <- tcExtendTyVarEnv2 rhs_tvs    $
+	; (co_fn, matches') <- tcExtendTyVarEnv2 rhs_tvs $
 		    	       tcMatchesFun mono_name inf matches mono_ty
 
 	; let fun_bind' = FunBind { fun_id = L nm_loc mono_id, 
@@ -574,9 +577,9 @@ tcMonoBinds binds sig_fn non_rec
 			 	-- A monomorphic binding for each term variable that lacks 
 				-- a type sig.  (Ones with a sig are already in scope.)
 
-	; binds' <- tcExtendIdEnv2    rhs_id_env $
+	; binds' <- tcExtendIdEnv2 rhs_id_env $ do
 		    traceTc (text "tcMonoBinds" <+> vcat [ ppr n <+> ppr id <+> ppr (idType id) 
-							 | (n,id) <- rhs_id_env]) `thenM_`
+							 | (n,id) <- rhs_id_env])
 		    mapM (wrapLocM tcRhs) tc_binds
 	; return (listToBag binds', mono_info) }
 
@@ -662,7 +665,11 @@ tcLhs sig_fn other_bind = pprPanic "tcLhs" (ppr other_bind)
 
 -------------------
 tcRhs :: TcMonoBind -> TcM (HsBind TcId)
-tcRhs (TcFunBind info fun'@(L _ mono_id) inf matches)
+-- When we are doing pattern bindings, or multiple function bindings at a time
+-- we *don't* bring any scoped type variables into scope
+-- Wny not?  They are not completely rigid.
+-- That's why we have the special case for a single FunBind in tcMonoBinds
+tcRhs (TcFunBind (_,_,mono_id) fun' inf matches)
   = do	{ (co_fn, matches') <- tcMatchesFun (idName mono_id) inf 
 				    	    matches (idType mono_id)
 	; return (FunBind { fun_id = fun', fun_infix = inf, fun_matches = matches',
@@ -738,7 +745,7 @@ generalise dflags top_lvl bind_list sig_fn mono_infos lie_req
    	-- Check that signature type variables are OK
 	; final_qtvs <- checkSigsTyVars qtvs sigs
 
-	; returnM (final_qtvs, sig_lie, binds) }
+	; return (final_qtvs, sig_lie, binds) }
   where
     bndrs   = bndrNames mono_infos
     sigs    = [sig | (_, Just sig, _) <- mono_infos]
@@ -794,7 +801,7 @@ unifyCtxts (sig1 : sigs) 	-- Argument is always non-empty
 checkSigsTyVars :: [TcTyVar] -> [TcSigInfo] -> TcM [TcTyVar]
 checkSigsTyVars qtvs sigs 
   = do	{ gbl_tvs <- tcGetGlobalTyVars
-	; sig_tvs_s <- mappM (check_sig gbl_tvs) sigs
+	; sig_tvs_s <- mapM (check_sig gbl_tvs) sigs
 
 	; let	-- Sigh.  Make sure that all the tyvars in the type sigs
 		-- appear in the returned ty var list, which is what we are
@@ -806,15 +813,15 @@ checkSigsTyVars qtvs sigs
 		-- Here, 'a' won't appear in qtvs, so we have to add it
 	 	sig_tvs = foldl extendVarSetList emptyVarSet sig_tvs_s
 		all_tvs = varSetElems (extendVarSetList sig_tvs qtvs)
-	; returnM all_tvs }
+	; return all_tvs }
   where
     check_sig gbl_tvs (TcSigInfo {sig_id = id, sig_tvs = tvs, 
 				  sig_theta = theta, sig_tau = tau})
       = addErrCtxt (ptext SLIT("In the type signature for") <+> quotes (ppr id))	$
 	addErrCtxtM (sigCtxt id tvs theta tau)						$
 	do { tvs' <- checkDistinctTyVars tvs
-	   ; ifM (any (`elemVarSet` gbl_tvs) tvs')
-		 (bleatEscapedTvs gbl_tvs tvs tvs') 
+	   ; when (any (`elemVarSet` gbl_tvs) tvs')
+	          (bleatEscapedTvs gbl_tvs tvs tvs')
 	   ; return tvs' }
 
 checkDistinctTyVars :: [TcTyVar] -> TcM [TcTyVar]
@@ -970,6 +977,44 @@ The @TcSigInfo@ contains @TcTypes@ because they are unified with
 the variable's type, and after that checked to see whether they've
 been instantiated.
 
+Note [Scoped tyvars]
+~~~~~~~~~~~~~~~~~~~~
+The -XScopedTypeVariables flag brings lexically-scoped type variables
+into scope for any explicitly forall-quantified type variables:
+	f :: forall a. a -> a
+	f x = e
+Then 'a' is in scope inside 'e'.
+
+However, we do *not* support this 
+  - For pattern bindings e.g
+	f :: forall a. a->a
+	(f,g) = e
+
+  - For multiple function bindings, unless Opt_RelaxedPolyRec is on
+   	f :: forall a. a -> a
+	f = g
+   	g :: forall b. b -> b
+	g = ...f...
+    Reason: we use mutable variables for 'a' and 'b', since they may
+    unify to each other, and that means the scoped type variable would
+    not stand for a completely rigid variable.
+
+    Currently, we simply make Opt_ScopedTypeVariables imply Opt_RelaxedPolyRec
+
+
+Note [More instantiated than scoped]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+There may be more instantiated type variables than lexically-scoped 
+ones.  For example:
+	type T a = forall b. b -> (a,b)
+	f :: forall c. T c
+Here, the signature for f will have one scoped type variable, c,
+but two instantiated type variables, c' and b'.  
+
+We assume that the scoped ones are at the *front* of sig_tvs,
+and remember the names from the original HsForAllTy in the TcSigFun.
+
+
 \begin{code}
 type TcSigFun = Name -> Maybe [Name]	-- Maps a let-binder to the list of
 					-- type variables brought into scope
@@ -986,7 +1031,7 @@ mkTcSigFun sigs = lookupNameEnv env
 		    | L span (TypeSig (L _ name) lhs_ty) <- sigs]
 	-- The scoped names are the ones explicitly mentioned
 	-- in the HsForAll.  (There may be more in sigma_ty, because
-	-- of nested type synonyms.  See Note [Scoped] with TcSigInfo.)
+	-- of nested type synonyms.  See Note [More instantiated than scoped].)
 	-- See Note [Only scoped tyvars are in the TyVarEnv]
 
 ---------------
@@ -994,10 +1039,6 @@ data TcSigInfo
   = TcSigInfo {
 	sig_id     :: TcId,		--  *Polymorphic* binder for this value...
 
-	sig_scoped :: [Name],		-- Names for any scoped type variables
-					-- Invariant: correspond 1-1 with an initial
-					-- segment of sig_tvs (see Note [Scoped])
-
 	sig_tvs    :: [TcTyVar],	-- Instantiated type variables
 					-- See Note [Instantiate sig]
 
@@ -1019,17 +1060,6 @@ data TcSigInfo
 -- only the lexically scoped ones into the environment.
 
 
--- 	Note [Scoped]
--- There may be more instantiated type variables than scoped 
--- ones.  For example:
---	type T a = forall b. b -> (a,b)
---	f :: forall c. T c
--- Here, the signature for f will have one scoped type variable, c,
--- but two instantiated type variables, c' and b'.  
---
--- We assume that the scoped ones are at the *front* of sig_tvs,
--- and remember the names from the original HsForAllTy in sig_scoped
-
 -- 	Note [Instantiate sig]
 -- It's vital to instantiate a type signature with fresh variables.
 -- For example:
@@ -1060,10 +1090,12 @@ tcInstSig_maybe :: TcSigFun -> Name -> TcM (Maybe TcSigInfo)
 tcInstSig_maybe sig_fn name 
   = case sig_fn name of
 	Nothing  -> return Nothing
-	Just tvs -> do	{ tc_sig <- tcInstSig False name tvs
-			; return (Just tc_sig) }
+	Just scoped_tvs -> do	{ tc_sig <- tcInstSig False name
+				; return (Just tc_sig) }
+	-- NB: the scoped_tvs may be non-empty, but we can 
+	-- just ignore them.  See Note [Scoped tyvars].
 
-tcInstSig :: Bool -> Name -> [Name] -> TcM TcSigInfo
+tcInstSig :: Bool -> Name -> TcM TcSigInfo
 -- Instantiate the signature, with either skolems or meta-type variables
 -- depending on the use_skols boolean.  This variable is set True
 -- when we are typechecking a single function binding; and False for
@@ -1082,7 +1114,7 @@ tcInstSig :: Bool -> Name -> [Name] -> TcM TcSigInfo
 --
 -- We must not use the same 'a' from the defn of T at both places!!
 
-tcInstSig use_skols name scoped_names
+tcInstSig use_skols name
   = do	{ poly_id <- tcLookupId name	-- Cannot fail; the poly ids are put into 
 					-- scope when starting the binding group
 	; let skol_info = SigSkol (FunSigCtxt name)
@@ -1091,15 +1123,7 @@ tcInstSig use_skols name scoped_names
 	; loc <- getInstLoc (SigOrigin skol_info)
 	; return (TcSigInfo { sig_id = poly_id,
 			      sig_tvs = tvs, sig_theta = theta, sig_tau = tau, 
-			      sig_scoped = final_scoped_names, sig_loc = loc }) }
-		-- Note that the scoped_names and the sig_tvs will have
-		-- different Names. That's quite ok; when we bring the 
-		-- scoped_names into scope, we just bind them to the sig_tvs
-  where
-	-- We also only have scoped type variables when we are instantiating
-	-- with true skolems
-    final_scoped_names | use_skols = scoped_names
-		       | otherwise = []
+			      sig_loc = loc }) }
 
 -------------------
 isMonoGroup :: DynFlags -> [LHsBind Name] -> Bool
@@ -1176,5 +1200,5 @@ missingSigWarn True  name ty
 	; addWarnTcM (env1, mk_msg tidy_ty) }
   where
     mk_msg ty = vcat [ptext SLIT("Definition but no type signature for") <+> quotes (ppr name),
-		      sep [ptext SLIT("Inferred type:") <+> ppr name <+> dcolon <+> ppr ty]]
+		      sep [ptext SLIT("Inferred type:") <+> pprHsVar name <+> dcolon <+> ppr ty]]
 \end{code}