Abstract over all in-scope type variables when creating closures

[ghc-hetmet.git] / compiler / vectorise / Vectorise.hs

diff --git a/compiler/vectorise/Vectorise.hs b/compiler/vectorise/Vectorise.hs
index 96fe9d2..c974c20 100644 (file)
--- a/compiler/vectorise/Vectorise.hs
+++ b/compiler/vectorise/Vectorise.hs
@@ -33,6 +33,7 @@ import DsUtils              ( mkCoreTup, mkCoreTupTy )
 
 import PrelNames
 import TysWiredIn
+import TysPrim              ( intPrimTy )
 import BasicTypes           ( Boxity(..) )
 
 import Outputable
@@ -83,14 +84,12 @@ vectTopBind b@(Rec bs)
 vectTopBinder :: Var -> VM Var
 vectTopBinder var
   = do
-      vty <- liftM (mkForAllTys tyvars) $ vectType mono_ty
+      vty <- vectType (idType var)
       name <- cloneName mkVectOcc (getName var)
       let var' | isExportedId var = Id.mkExportedLocalId name vty
                | otherwise        = Id.mkLocalId         name vty
       defGlobalVar var var'
       return var'
-  where
-    (tyvars, mono_ty) = splitForAllTys (idType var)
     
 vectTopRhs :: CoreExpr -> VM CoreExpr
 vectTopRhs = liftM fst . closedV . vectPolyExpr (panic "Empty lifting context") . freeVars
@@ -176,7 +175,7 @@ abstractOverTyVars :: [TyVar] -> ((CoreExpr -> CoreExpr) -> VM a) -> VM a
 abstractOverTyVars tvs p
   = do
       mdicts <- mapM mk_dict_var tvs
-      zipWithM_ (\tv -> maybe (deleteTyVarPA tv) (extendTyVarPA tv . Var)) tvs mdicts
+      zipWithM_ (\tv -> maybe (defLocalTyVar tv) (defLocalTyVarWithPA tv . Var)) tvs mdicts
       p (mk_lams mdicts)
   where
     mk_dict_var tv = do
@@ -185,16 +184,13 @@ abstractOverTyVars tvs p
                          Just ty -> liftM Just (newLocalVar FSLIT("dPA") ty)
                          Nothing -> return Nothing
 
-    mk_lams mdicts = mkLams [arg | (tv, mdict) <- zip tvs mdicts
-                                 , arg <- tv : maybeToList mdict]
+    mk_lams mdicts = mkLams (tvs ++ [dict | Just dict <- mdicts])
 
 applyToTypes :: CoreExpr -> [Type] -> VM CoreExpr
 applyToTypes expr tys
   = do
       dicts <- mapM paDictOfType tys
-      return $ mkApps expr [arg | (ty, dict) <- zip tys dicts
-                                , arg <- [Type ty, dict]]
-    
+      return $ expr `mkTyApps` tys `mkApps` dicts
 
 vectPolyExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
 vectPolyExpr lc expr
@@ -266,7 +262,7 @@ vectExpr lc e@(_, AnnLam bndr body)
 
 vectExpr lc (fvs, AnnLam bndr body)
   = do
-      let tyvars = filter isTyVar (varSetElems fvs)
+      tyvars <- localTyVars
       info <- mkCEnvInfo fvs bndr body
       (poly_vfn, poly_lfn) <- mkClosureFns info tyvars bndr body
 
@@ -376,7 +372,7 @@ mkClosureFns info tyvars arg body
 mkClosureMonoFns :: CEnvInfo -> Var -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
 mkClosureMonoFns info arg body
   = do
-      lc_bndr <- newLocalVar FSLIT("lc") intTy
+      lc_bndr <- newLocalVar FSLIT("lc") intPrimTy
       (varg : vbndrs, larg : lbndrs, (vbody, lbody))
         <- vectBndrsIn (arg : cenv_vars info)
                        (vectExpr (Var lc_bndr) body)
@@ -405,17 +401,21 @@ mkClosureMonoFns info arg body
           return . Let (NonRec lbndr lenv)
                  $ Case (mkApps (Var lengthPA) [Type vty, (Var lbndr)])
                         lc_bndr
-                        intTy
+                        (exprType lbody)
                         [(DEFAULT, [], lbody)]
 
     bind_lenv lenv lbody lc_bndr lbndrs
-      = return
-      $ Case (unwrapFamInstScrut (cenv_repr_tycon info)
-                                 (cenv_repr_tyargs info)
-                                 lenv)
-             (mkWildId lty)
+      = let scrut = unwrapFamInstScrut (cenv_repr_tycon info)
+                                       (cenv_repr_tyargs info)
+                                       lenv
+            lbndrs' | null lbndrs = [mkWildId unitTy]
+                    | otherwise   = lbndrs
+        in
+        return
+      $ Case scrut
+             (mkWildId (exprType scrut))
              (exprType lbody)
-             [(DataAlt (cenv_repr_datacon info), lc_bndr : lbndrs, lbody)]
+             [(DataAlt (cenv_repr_datacon info), lc_bndr : lbndrs', lbody)]
           
 vectTyAppExpr :: CoreExpr -> CoreExprWithFVs -> [Type] -> VM (CoreExpr, CoreExpr)
 vectTyAppExpr lc (_, AnnVar v) tys = vectPolyVar lc v tys
@@ -438,20 +438,19 @@ vectTyCon tc
                     Nothing  -> pprTrace "ccTyCon:" (ppr tc) $ return tc
 
 vectType :: Type -> VM Type
-vectType ty | Just ty' <- coreView ty = vectType ty
+vectType ty | Just ty' <- coreView ty = vectType ty'
 vectType (TyVarTy tv) = return $ TyVarTy tv
 vectType (AppTy ty1 ty2) = liftM2 AppTy (vectType ty1) (vectType ty2)
 vectType (TyConApp tc tys) = liftM2 TyConApp (vectTyCon tc) (mapM vectType tys)
 vectType (FunTy ty1 ty2)   = liftM2 TyConApp (builtin closureTyCon)
                                              (mapM vectType [ty1,ty2])
-vectType (ForAllTy tv ty)
+vectType ty@(ForAllTy _ _)
   = do
-      r   <- paDictArgType tv
-      ty' <- vectType ty
-      return $ ForAllTy tv (wrap r ty')
+      mdicts   <- mapM paDictArgType tyvars
+      mono_ty' <- vectType mono_ty
+      return $ tyvars `mkForAllTys` ([dict | Just dict <- mdicts] `mkFunTys` mono_ty')
   where
-    wrap Nothing      = id
-    wrap (Just pa_ty) = FunTy pa_ty
+    (tyvars, mono_ty) = splitForAllTys ty
 
 vectType ty = pprPanic "vectType:" (ppr ty)