[project @ 2001-10-25 02:13:10 by sof]

[ghc-hetmet.git] / ghc / compiler / usageSP / UsageSPInf.lhs

diff --git a/ghc/compiler/usageSP/UsageSPInf.lhs b/ghc/compiler/usageSP/UsageSPInf.lhs
index 0cdf16f..cce3ffe 100644 (file)
--- a/ghc/compiler/usageSP/UsageSPInf.lhs
+++ b/ghc/compiler/usageSP/UsageSPInf.lhs
@@ -18,30 +18,27 @@ import UsageSPLint
 import UConSet
 
 import CoreSyn
-import CoreFVs         ( mustHaveLocalBinding )
 import Rules            ( RuleBase )
 import TypeRep          ( Type(..), TyNote(..) ) -- friend
-import Type             ( UsageAnn(..),
-                          applyTy, applyTys,
-                          splitFunTy_maybe, splitFunTys, splitTyConApp_maybe,
-                          mkUsgTy, splitUsgTy, isUsgTy, isNotUsgTy, unUsgTy, tyUsg,
-                          splitUsForAllTys, substUsTy,
+import Type             ( applyTy, applyTys,
+                          splitFunTy_maybe, splitFunTys, splitTyConApp,
                           mkFunTy, mkForAllTy )
 import TyCon            ( tyConArgVrcs_maybe, isFunTyCon )
 import Literal          ( Literal(..), literalType )
-import Var              ( Var, UVar, varType, setVarType, mkUVar, modifyIdInfo )
+import Var              ( Var, varType, setVarType, modifyIdInfo )
 import IdInfo           ( setLBVarInfo, LBVarInfo(..) )
 import Id               ( isExportedId )
 import VarEnv
 import VarSet
 import UniqSupply       ( UniqSupply, UniqSM,
                           initUs, splitUniqSupply )
+import Util             ( lengthExceeds )
 import Outputable
 import Maybes           ( expectJust )
 import List             ( unzip4 )
-import CmdLineOpts     ( opt_D_dump_usagesp, opt_DoUSPLinting, opt_UsageSPOn )
-import CoreLint                ( beginPass, endPass )
-import ErrUtils                ( doIfSet, dumpIfSet )
+import CmdLineOpts     ( DynFlags, DynFlag(..), dopt, opt_UsageSPOn )
+import CoreLint                ( showPass, endPass )
+import ErrUtils                ( doIfSet_dyn, dumpIfSet_dyn )
 import PprCore          ( pprCoreBindings )
 \end{code}
 
@@ -89,29 +86,36 @@ The inference is done over a set of @CoreBind@s, and inside the IO
 monad.
 
 \begin{code}
-doUsageSPInf :: UniqSupply
+doUsageSPInf :: DynFlags 
+            -> UniqSupply
              -> [CoreBind]
-             -> RuleBase
              -> IO [CoreBind]
 
-doUsageSPInf us binds local_rules
+doUsageSPInf dflags us binds
   | not opt_UsageSPOn
-  = do { printErrs (text "WARNING: ignoring requested -fusagesp pass; requires -fusagesp-on") ;
+  = do { printDump (text "WARNING: ignoring requested -fusagesp pass; requires -fusagesp-on") ;
         return binds
     }
-      
+
+{- ENTIRE PASS COMMENTED OUT FOR NOW  -- KSW 2000-10-13
+
+   This monomorphic version of the analysis is outdated.  I'm
+   currently ripping out the old one and inserting the new one.  For
+   now, I'm simply commenting out this entire pass.
+
+
   | otherwise
   = do
         let binds1 = doUnAnnotBinds binds
 
-       beginPass "UsageSPInf"
+       showPass dflags "UsageSPInf"
 
-        dumpIfSet opt_D_dump_usagesp "UsageSPInf unannot'd" $
+        dumpIfSet_dyn dflags Opt_D_dump_usagesp "UsageSPInf unannot'd" $
                              pprCoreBindings binds1
 
         let ((binds2,ucs,_),_) = initUs us (uniqSMMToUs (usgInfBinds emptyVarEnv binds1))
 
-        dumpIfSet opt_D_dump_usagesp "UsageSPInf annot'd" $
+        dumpIfSet_dyn dflags Opt_D_dump_usagesp "UsageSPInf annot'd" $
           pprCoreBindings binds2
        
         let ms     = solveUCS ucs
@@ -120,12 +124,12 @@ doUsageSPInf us binds local_rules
                        Nothing -> panic "doUsageSPInf: insol. conset!"
             binds3 = appUSubstBinds s binds2
        
-        doIfSet opt_DoUSPLinting $
+        doIfSet_dyn dflags Opt_DoUSPLinting $
           do doLintUSPAnnotsBinds binds3     -- lint check 1
              doLintUSPConstBinds  binds3     -- lint check 2 (force solution)
              doCheckIfWorseUSP binds binds3  -- check for worsening of usages
        
-        endPass "UsageSPInf" opt_D_dump_usagesp binds3
+        endPass dflags "UsageSPInf" (dopt Opt_D_dump_usagesp dflags) binds3
        
         return binds3
 \end{code}
@@ -348,7 +352,7 @@ usgInfCE ve e0@(Case e1 v1 alts)
        (e2,y2u,h2,f2) <- usgInfCE ve e1
        let h3       = usgEqTy y2u y1u -- **! why not subty?
            (u2,y2)  = splitUsgTy y2u
-           (tc,y2s) = expectJust "usgInfCE:Case" $ splitTyConApp_maybe y2
+           (tc,y2s) = splitTyConApp y2
            (cs,v1ss,es) = unzip3 alts
            v2ss     = map (map (\ v -> setVarType v (mkUsgTy u2 (annotManyN (varType v)))))
                           v1ss
@@ -474,7 +478,7 @@ pessimise ty
     pessN co ve     (NoteTy (FTVNote _)    ty) = pessN co ve ty
     pessN co ve     (TyVarTy _)                = emptyUConSet
     pessN co ve     (AppTy _ _)                = emptyUConSet
-    pessN co ve     (TyConApp tc tys)          = ASSERT( not((isFunTyCon tc)&&(length tys > 1)) )
+    pessN co ve     (TyConApp tc tys)          = ASSERT( not((isFunTyCon tc)&&( tys `lengthExceeds` 1)) )
                                                  emptyUConSet
     pessN co ve     (FunTy ty1 ty2)            = pess (not co) ve ty1 `unionUCS` pess co ve ty2
     pessN co ve     (ForAllTy _ ty)            = pessN co ve ty
@@ -660,6 +664,9 @@ isUnAnnotated (AppTy ty1 ty2)           = isUnAnnotated ty1 && isUnAnnotated ty2
 isUnAnnotated (TyConApp tc tys)         = all isUnAnnotated tys
 isUnAnnotated (FunTy ty1 ty2)           = isUnAnnotated ty1 && isUnAnnotated ty2
 isUnAnnotated (ForAllTy tyv ty)         = isUnAnnotated ty
+
+
+END OF ENTIRELY-COMMENTED-OUT PASS   -- KSW 2000-10-13 -}
 \end{code}
 
 ======================================================================