ghc-9.10.1: GHC/JS/Opt/Simple.hs
-----------------------------------------------------------------------------
-- |
-- Module : GHC.JS.Opt.Simple
-- Copyright : (c) The University of Glasgow 2001
-- License : BSD-style (see the file LICENSE)
--
-- Maintainer : Jeffrey Young <jeffrey.young@iohk.io>
-- Luite Stegeman <luite.stegeman@iohk.io>
-- Sylvain Henry <sylvain.henry@iohk.io>
-- Josh Meredith <josh.meredith@iohk.io>
-- Stability : experimental
--
--
-- * Simple optimizer for the JavaScript IR
--
-- This is a simple optimizer for the JavaScript IR. It is intended to be
-- the first optimization pass after generating the JavaScript IR.
--
-- * Design
--
-- The optimizer is invoked on the top-level JStat. It leaves the top-level
-- scope alone, but traverses into each function body and optimizes it.
-- Nested functions are mostly left alone, since they are uncommon in
-- generated code.
--
-- The optimizations are:
--
-- - rename local variables to shorter names
-- - remove unused variables
-- - remove trivial assignments: x = x
-- - "float" expressions without side effects:
-- - var x = 1; var y = x + 1; -> var y = 1 + 1;
--
-- * Limitations
--
-- The simple optimization pass is intended to be fast and applicable to
-- almost all generated JavaScript code. Limitations are:
--
-- - optimization is disabled if an `eval` statement is encountered
-- - variables declared in nested scopes are not renamed
--
-----------------------------------------------------------------------------
{-# LANGUAGE OverloadedStrings #-}
module GHC.JS.Opt.Simple (simpleOpt) where
import GHC.Prelude
import GHC.JS.Opt.Expr
import GHC.JS.Syntax
import GHC.Data.FastString
import qualified GHC.Types.Unique.Map as UM
import GHC.Types.Unique.Map (UniqMap)
import qualified GHC.Types.Unique.Set as US
import Control.Monad
import Data.Function
import Data.List (sortBy)
import Data.Maybe
import qualified Data.Semigroup as Semi
data Multiplicity = Zero | One | Many
deriving (Eq, Ord, Show)
data VarValue = Unassigned
| AssignedOnce
| AssignedOnceKnown !JExpr
| AssignedMany
data VarDecl = NoDecl -- not declared in analyzed scope (possibly deeper or global)
| ArgDecl !Int -- argument in analyzed scope
| LocalDecl !Int -- local variable in analyzed scope
deriving (Eq, Show)
isLocalOrArg :: VarDecl -> Bool
isLocalOrArg (LocalDecl {}) = True
isLocalOrArg (ArgDecl {}) = True
isLocalOrArg _ = False
isDecl :: VarDecl -> Bool
isDecl NoDecl = False
isDecl _ = True
instance Semi.Semigroup VarDecl where
NoDecl <> x = x
x <> NoDecl = x
ArgDecl n <> ArgDecl m = ArgDecl (min n m)
LocalDecl n <> LocalDecl m = LocalDecl (min n m)
ArgDecl n <> _ = ArgDecl n
_ <> ArgDecl n = ArgDecl n
instance Ord VarDecl where
compare NoDecl NoDecl = EQ
compare NoDecl _ = LT
compare _ NoDecl = GT
compare (ArgDecl n) (ArgDecl m) = compare n m
compare (ArgDecl {}) _ = LT
compare _ (ArgDecl {}) = GT
compare (LocalDecl n) (LocalDecl m) = compare n m
data JFunction = JFunction [Ident] JStat
instance Semi.Semigroup VarValue where
Unassigned <> x = x
x <> Unassigned = x
_ <> _ = AssignedMany
instance Monoid VarValue where
mempty = Unassigned
mappend = (Semi.<>)
instance Semigroup Multiplicity where
Zero <> x = x
x <> Zero = x
_ <> _ = Many
instance Monoid Multiplicity where
mempty = Zero
mappend = (Semi.<>)
data VarUsage = VarUsage
{ varUsed :: !Multiplicity
, varAssigned :: !VarValue
, varDeclared :: !VarDecl
, varDeepDeclared :: !Bool
}
assignedMultiple :: VarUsage -> Bool
assignedMultiple VarUsage { varAssigned = AssignedMany } = True
assignedMultiple _ = False
data SimpleRewrite = SimpleRewrite
{ renameVar :: UniqMap Ident Ident
, varUsage :: UniqMap Ident VarUsage
}
instance Semigroup VarUsage where
x <> y = VarUsage
{ varUsed = varUsed x Semi.<> varUsed y
, varAssigned = varAssigned x Semi.<> varAssigned y
, varDeclared = varDeclared x Semi.<> varDeclared y
, varDeepDeclared = varDeepDeclared x || varDeepDeclared y
}
instance Monoid VarUsage where
mempty = VarUsage Zero Unassigned NoDecl False
disableOpt :: Bool
-- disableOpt = True
disableOpt = False
simpleOpt :: JStat -> JStat
simpleOpt x | disableOpt = x
simpleOpt (BlockStat xs) = BlockStat (map simpleOpt xs)
simpleOpt (AssignStat lhs AssignOp (ValExpr (JFunc args body))) =
let JFunction args' body' = simpleOptFunction (JFunction args body)
in AssignStat lhs AssignOp (ValExpr (JFunc args' body'))
simpleOpt (FuncStat name args body) =
let JFunction args' body' = simpleOptFunction (JFunction args body)
in FuncStat name args' body'
simpleOpt s = s
simpleOptFunction :: JFunction -> JFunction
simpleOptFunction jf = s_opt
where
-- we need to run it twice since floating in the first pass can
-- cause unused variables that can be removed in the second pass
s_opt = functionOptExprs $ maybe jf (`simpleRewrite` s_opt0) mb_rw
mb_rw = mkRewrite True (simpleAnalyze s_opt0)
s_opt0 = functionOptExprs $ maybe jf (`simpleRewrite` jf) mb_rw0
mb_rw0 = mkRewrite False (simpleAnalyze jf)
functionOptExprs :: JFunction -> JFunction
functionOptExprs (JFunction args s) = JFunction args (optExprs s)
newLocals :: [Ident]
newLocals = filter (not . isReserved ) $
map (TxtI . mkFastString) $
map (:[]) chars0 ++ concatMap mkIdents [1..]
where
mkIdents n = [c0:cs | c0 <- chars0, cs <- replicateM n chars]
chars0 = ['a'..'z']++['A'..'Z']
chars = chars0++['0'..'9']
isReserved (TxtI i) = i `US.elementOfUniqSet` reservedSet
reservedSet = US.mkUniqSet reserved
reserved = [ -- reserved words
"abstract", "arguments", "await", "boolean"
, "break", "byte", "case", "catch"
, "char", "class", "const", "continue"
, "debugger", "default", "delete", "do"
, "double", "else", "enum", "eval"
, "export", "extends", "false", "final"
, "finally", "float", "for", "function"
, "goto", "if", "implements", "import"
, "in", "instanceof", "int", "interface"
, "let", "long", "native", "new"
, "null", "package", "private", "protected"
, "public", "return", "short", "static"
, "super", "switch", "synchronized", "this"
, "throw", "throws", "transient", "true"
, "try", "typeof", "var", "void"
, "volatile", "while", "with", "yield"
-- some special values
, "as", "async", "from", "get"
, "of", "NaN", "prototype", "undefined"
]
mkRewrite :: Bool -> AnalysisResult -> Maybe SimpleRewrite
mkRewrite do_rename a
| arBailout a = Nothing
| otherwise = Just $
SimpleRewrite { renameVar = if do_rename
then UM.listToUniqMap (zip localVars newVars)
else UM.emptyUniqMap
, varUsage = vu
}
where
vu :: UM.UniqMap Ident VarUsage
vu = arVarUsage a
-- local variables in the order that they were declared
localVars :: [Ident]
localVars =
map fst
-- recover original order and remove non-determinism
. sortBy (compare `on` snd)
. map (\(v, u) -> (v, varDeclared u))
. filter (isDecl . varDeclared . snd)
-- non-determinism is removed by sorting afterwards
$ UM.nonDetUniqMapToList vu
-- we can't rename variables that are used in the global scope
blockedNames :: US.UniqSet Ident
blockedNames =
US.mkUniqSet $
map fst (
filter (\(_k,v) -> (not . isDecl) (varDeclared v) || varDeepDeclared v)
(UM.nonDetUniqMapToList vu))
newVars :: [Ident]
newVars = filter (not . (`US.elementOfUniqSet` blockedNames)) newLocals
simpleRewrite :: SimpleRewrite -> JFunction -> JFunction
simpleRewrite rw (JFunction args stat)= JFunction (map varReplace args) (go stat)
where
zeroUsed :: JExpr -> Bool
zeroUsed (ValExpr (JVar v)) =
maybe True ((== Zero) . varUsed) (UM.lookupUniqMap (varUsage rw) v) &&
maybe False (isDecl . varDeclared) (UM.lookupUniqMap (varUsage rw) v)
zeroUsed _ = False
varReplace :: Ident -> Ident
varReplace v = fromMaybe v (UM.lookupUniqMap (renameVar rw) v)
{-
We can sometimes float down an expression to avoid an assignment:
var x = e;
f(x);
==>
f(e);
This can only be done if the expression has no side effects and x is
only used once.
Heap object property lookups cannot be floated just yet, since we
don't know whether an object is mutable or not. For example a thunk
can be blackholed, which would change the result if we float the lookup
after the blackholing.
-}
mayBeFloated :: JExpr -> Bool
mayBeFloated (ValExpr v) = mayBeFloatedV v
mayBeFloated (SelExpr _e _) = False
mayBeFloated (IdxExpr _e1 _e2) = False
mayBeFloated (InfixExpr _ e1 e2)= mayBeFloated e1 && mayBeFloated e2
mayBeFloated (UOpExpr _ _e) = False
mayBeFloated (IfExpr e1 e2 e3) = mayBeFloated e1 &&
mayBeFloated e2 &&
mayBeFloated e3
mayBeFloated (ApplExpr e es)
| ValExpr (JVar (TxtI i)) <- e, isClosureAllocator i = all mayBeFloated es
| otherwise = False
mayBeFloatedV :: JVal -> Bool
mayBeFloatedV (JVar v)
| Just vu <- UM.lookupUniqMap (varUsage rw) v
= isDecl (varDeclared vu) && not (assignedMultiple vu)
| otherwise = False
mayBeFloatedV (JList es) = all mayBeFloated es
mayBeFloatedV (JDouble {}) = True
mayBeFloatedV (JInt {}) = True
mayBeFloatedV (JStr {}) = True
mayBeFloatedV (JRegEx {}) = True
mayBeFloatedV (JBool {}) = True
mayBeFloatedV (JHash ps) = all (mayBeFloated . snd)
(UM.nonDetUniqMapToList ps)
mayBeFloatedV (JFunc {}) = False
{-
we allow small literals and local variables and arguments to be
duplicated, since they tend to take up little space.
-}
mayDuplicate :: JExpr -> Bool
mayDuplicate (ValExpr (JVar i))
| Just vu <- (UM.lookupUniqMap (varUsage rw) i)
= isLocalOrArg (varDeclared vu)
mayDuplicate (ValExpr (JInt n)) = abs n < 1000000
mayDuplicate (ValExpr (JDouble {})) = True
mayDuplicate _ = False
zeroAssigned :: Ident -> Bool
zeroAssigned v
| Just vu <- UM.lookupUniqMap (varUsage rw) v
= case varAssigned vu of
Unassigned -> True
_ -> False
| otherwise = False
assignedAtMostOnce :: Ident -> Bool
assignedAtMostOnce v
| Just vu <- UM.lookupUniqMap (varUsage rw) v =
case varAssigned vu of
Unassigned -> True
AssignedOnce -> True
AssignedOnceKnown {} -> True
AssignedMany -> False
| otherwise = False
go :: JStat -> JStat
go (DeclStat v mb_e)
| zeroUsed (ValExpr (JVar v)) =
case mb_e of
Nothing | zeroAssigned v -> BlockStat []
| otherwise -> DeclStat (varReplace v) Nothing
Just e | not (mayHaveSideEffects e) && assignedAtMostOnce v
-> BlockStat []
| otherwise -> DeclStat (varReplace v) (Just (goE True e))
| otherwise = DeclStat (varReplace v) (fmap (goE True) mb_e)
go (AssignStat lhs aop e)
| ValExpr (JVar i) <- lhs, isTrivialAssignment i aop e = BlockStat []
| zeroUsed lhs && not (mayHaveSideEffects e) = BlockStat []
| zeroUsed lhs = AssignStat (goE False lhs) aop (goE True e)
| otherwise = AssignStat (goE False lhs) aop (goE True e)
go (ReturnStat e) = ReturnStat (goE True e)
go (BlockStat ss) = flattenBlock (map go ss)
go (IfStat e s1 s2) = IfStat (goE True e) (go s1) (go s2)
go (WhileStat b e s) = WhileStat b (goE True e) (go s)
go (ForStat s1 e s2 s3) = ForStat (go s1) (goE True e) (go s2) (go s3)
go (ForInStat b v e s) = ForInStat b (varReplace v) (goE True e) (go s)
go (SwitchStat e cases s) = SwitchStat (goE True e)
(map (\(c,cs) -> (c, go cs)) cases)
(go s)
go (TryStat s1 v s2 s3) = TryStat (go s1) (varReplace v) (go s2) (go s3)
go (ApplStat e es) = ApplStat (goE True e) (map (goE True) es)
go (UOpStat uop e) = UOpStat uop (goE False e)
go (LabelStat lbl s) = LabelStat lbl (go s)
go s@(BreakStat {}) = s
go s@(ContinueStat {}) = s
go (FuncStat i args s) = FuncStat i (map varReplace args) (go s)
goE :: Bool -> JExpr -> JExpr
goE rhs (ValExpr (JVar v))
| rhs
, Just vu <- UM.lookupUniqMap (varUsage rw) v
, AssignedOnceKnown ee <- varAssigned vu
, varUsed vu == One || mayDuplicate ee
, isDecl (varDeclared vu)
, mayBeFloated ee
= goE rhs ee
goE _rhs (ValExpr v) = ValExpr (goV v)
goE rhs (SelExpr e i) = SelExpr (goE rhs e) i
goE rhs (IdxExpr e1 e2) = IdxExpr (goE rhs e1) (goE rhs e2)
goE rhs (InfixExpr op e1 e2) = InfixExpr op (goE rhs e1) (goE rhs e2)
goE rhs (UOpExpr op e) = UOpExpr op (goE rhs e)
goE rhs (IfExpr e1 e2 e3) = IfExpr (goE rhs e1) (goE rhs e2) (goE rhs e3)
goE rhs (ApplExpr e es) = ApplExpr (goE rhs e) (map (goE rhs) es)
goV :: JVal -> JVal
goV (JVar v) = JVar (varReplace v)
goV (JList es) = JList (map (goE True) es)
goV (JHash ps) = JHash (fmap (goE True) ps)
goV v@(JFunc {}) = v
goV v@(JDouble {}) = v
goV v@(JInt {}) = v
goV v@(JStr {}) = v
goV v@(JRegEx {}) = v
goV v@(JBool {}) = v
flattenBlock :: [JStat] -> JStat
flattenBlock stats =
case filter (/= BlockStat []) stats of
[] -> BlockStat []
[s] -> s
ss -> BlockStat ss
data AnalysisResult = AnalysisResult
{ arBailout :: !Bool
, arVarUsage :: !(UniqMap Ident VarUsage)
, arDeclaredCount :: !Int
}
simpleAnalyze :: JFunction -> AnalysisResult
simpleAnalyze (JFunction args body) = go False (AnalysisResult False start 0) body
where
start :: UniqMap Ident VarUsage
start = UM.listToUniqMap
$ zipWith (\n v -> (v, VarUsage Zero Unassigned (ArgDecl n) False))
[0..]
args
add :: Ident -> VarUsage -> AnalysisResult -> AnalysisResult
add i vu m = m { arVarUsage = UM.addToUniqMap_C (Semi.<>) (arVarUsage m) i vu }
declare :: Bool -> Ident -> Maybe JExpr -> AnalysisResult -> AnalysisResult
declare True i _assign m = -- declaration in deeper scope
let vu = VarUsage Zero AssignedMany NoDecl True
in m { arVarUsage = UM.addToUniqMap_C (Semi.<>) (arVarUsage m) i vu}
declare False i assign m = -- declaration in analyzed scope
let count = arDeclaredCount m
!newCount
| Just (VarUsage _ _ (LocalDecl _) _) <-
UM.lookupUniqMap (arVarUsage m) i = count -- already declared
| otherwise = count + 1
vassign | Just e <- assign = AssignedOnceKnown e
| otherwise = Unassigned
!vu = VarUsage Zero vassign (LocalDecl count) False
in m { arDeclaredCount = newCount
, arVarUsage = UM.addToUniqMap_C (Semi.<>) (arVarUsage m) i vu
}
go :: Bool -> AnalysisResult -> JStat -> AnalysisResult
go deep u (DeclStat v mb_e) =
case mb_e of
Nothing -> declare deep v mb_e u
Just e -> declare deep v mb_e (goE u e)
go _deep u (AssignStat (ValExpr (JVar v)) aop e) =
let use = case aop of
AssignOp -> Zero
_ -> One
in add v (VarUsage use (AssignedOnceKnown e) NoDecl False) (goE u e)
go _deep u (AssignStat lhs _aop rhs) = goE (goE u lhs) rhs
go _deep u (ReturnStat e) = goE u e
go deep u (BlockStat ss) = foldl' (go deep) u ss
go deep u (IfStat e s1 s2) = go deep (go deep (goE u e) s1) s2
go deep u (WhileStat _b e s) = go deep (goE u e) s
go deep u (ForStat s1 e s2 s3)
= go deep (go deep (goE (go deep u s1) e) s2) s3
go deep u (ForInStat b v e s) =
let !u' = if b then declare deep v Nothing u else u
in add v (VarUsage Zero AssignedMany NoDecl True)
(go deep (go deep (goE u' e) s) s)
go deep u (SwitchStat e cases s)
= go deep (goE (foldl' (go deep) u (map snd cases)) e) s
go deep u (TryStat s1 v s2 s3)
= add v (VarUsage Zero AssignedMany NoDecl True)
(go deep (go deep (go deep u s1) s2) s3)
go _deep u (ApplStat e es)
| (ValExpr (JVar (TxtI i))) <- e, i == "eval" = u { arBailout = True }
| otherwise = foldl' goE (goE u e) es
go _deep u (UOpStat op e)
| ValExpr (JVar v) <- e
, op `elem` [PreIncOp, PostIncOp, PreDecOp, PostDecOp] =
add v (VarUsage One AssignedOnce NoDecl False) u
| otherwise = goE u e
go deep u (LabelStat _ s) = go deep u s
go _deep u (BreakStat _) = u
go _deep u (ContinueStat _) = u
go _deep u (FuncStat _ vs s)
= go True (foldl' (\u v -> add v (VarUsage Zero AssignedOnce NoDecl True) u) u vs) s
goE :: AnalysisResult -> JExpr -> AnalysisResult
goE u (ValExpr v) = goV u v
goE u (SelExpr e _i) = goE u e
goE u (IdxExpr e1 e2) = goE (goE u e1) e2
goE u (InfixExpr _ e1 e2) = goE (goE u e1) e2
goE u (UOpExpr _ e) = goE u e
goE u (IfExpr e1 e2 e3) = goE (goE (goE u e1) e2) e3
goE u (ApplExpr e es)
| (ValExpr (JVar (TxtI i))) <- e, i == "eval" = u { arBailout = True }
| otherwise = foldl' goE (goE u e) es
goV :: AnalysisResult -> JVal -> AnalysisResult
goV u (JVar v) = add v (VarUsage One Unassigned NoDecl False) u
goV u (JList es) = foldl' goE u es
goV u (JDouble _) = u
goV u (JInt _) = u
goV u (JStr _) = u
goV u (JRegEx _) = u
goV u (JBool _) = u
goV u (JHash ps) = foldl' goE u (map snd $ UM.nonDetUniqMapToList ps)
goV u (JFunc vs s)
= go True (foldl (\u v -> add v (VarUsage Zero AssignedOnce NoDecl True) u) u vs) s
-- | A trivial assignment is an assignment of a variable to itself: x = x
isTrivialAssignment :: Ident -> AOp -> JExpr -> Bool
isTrivialAssignment v AssignOp (ValExpr (JVar v')) = v == v'
isTrivialAssignment _ _ _ = False
-- | Does the expression have side effects?
--
-- This only returns False if the expression definitely does not have side
-- effects, i.e. it can be removed without changing the semantics if the
-- result is not used.
--
-- Note: We have some assumptions here about Haskell RTS related values, which
-- may not be true for all JavaScript code. We should really replace
-- these with explicit nodes or annotations in the AST.
--
mayHaveSideEffects :: JExpr -> Bool
-- special cases for Haskell things. These should really be special operations
-- in the AST:
-- 1. stack indexing does not have side effects
mayHaveSideEffects (IdxExpr (ValExpr (JVar (TxtI i))) e)
| i == "h$stack" = mayHaveSideEffects e
-- 2. we assume that x.d1, x.d2, ... are heap object property lookups,
-- which do not have side effects
mayHaveSideEffects (SelExpr e (TxtI i))
| isHeapObjectProperty i = mayHaveSideEffects e
-- general cases (no Haskell RTS specific assumptions here):
mayHaveSideEffects (ValExpr v) = mayHaveSideEffectsV v
mayHaveSideEffects (SelExpr {}) = True
mayHaveSideEffects (IdxExpr {}) = True
mayHaveSideEffects (UOpExpr uop e) = uo || mayHaveSideEffects e
where
uo = case uop of
NotOp -> False
BNotOp -> False
NegOp -> False
PlusOp -> False
TypeofOp -> False
_ -> True
mayHaveSideEffects (InfixExpr _o e1 e2) =
mayHaveSideEffects e1 || mayHaveSideEffects e2
mayHaveSideEffects (IfExpr e1 e2 e3) =
mayHaveSideEffects e1 || mayHaveSideEffects e2 || mayHaveSideEffects e3
mayHaveSideEffects (ApplExpr {}) = True
mayHaveSideEffectsV :: JVal -> Bool
mayHaveSideEffectsV (JVar {}) = False
mayHaveSideEffectsV (JList es) = any mayHaveSideEffects es
mayHaveSideEffectsV (JDouble {}) = False
mayHaveSideEffectsV (JInt {}) = False
mayHaveSideEffectsV (JStr {}) = False
mayHaveSideEffectsV (JRegEx {}) = False
mayHaveSideEffectsV (JBool {}) = False
mayHaveSideEffectsV (JHash ps) = UM.anyUniqMap mayHaveSideEffects ps
mayHaveSideEffectsV (JFunc {}) = True
isHeapObjectProperty :: FastString -> Bool
isHeapObjectProperty "d1" = True
isHeapObjectProperty "d2" = True
isHeapObjectProperty "d3" = True
isHeapObjectProperty "d4" = True
isHeapObjectProperty "d5" = True
isHeapObjectProperty "d6" = True
isHeapObjectProperty "d7" = True
isHeapObjectProperty "d8" = True
isHeapObjectProperty "d9" = True
isHeapObjectProperty "d10" = True
isHeapObjectProperty "d11" = True
isHeapObjectProperty "d12" = True
isHeapObjectProperty "d13" = True
isHeapObjectProperty "d14" = True
isHeapObjectProperty "d15" = True
isHeapObjectProperty "d16" = True
isHeapObjectProperty "d17" = True
isHeapObjectProperty "d18" = True
isHeapObjectProperty "d19" = True
isHeapObjectProperty "d20" = True
isHeapObjectProperty "d21" = True
isHeapObjectProperty "d22" = True
isHeapObjectProperty "d23" = True
isHeapObjectProperty "d24" = True
isHeapObjectProperty _ = False
isClosureAllocator :: FastString -> Bool
isClosureAllocator "h$c1" = True
isClosureAllocator "h$c2" = True
isClosureAllocator "h$c3" = True
isClosureAllocator "h$c4" = True
isClosureAllocator "h$c5" = True
isClosureAllocator "h$c6" = True
isClosureAllocator "h$c7" = True
isClosureAllocator "h$c8" = True
isClosureAllocator "h$c9" = True
isClosureAllocator "h$c10" = True
isClosureAllocator "h$c11" = True
isClosureAllocator "h$c12" = True
isClosureAllocator "h$c13" = True
isClosureAllocator "h$c14" = True
isClosureAllocator "h$c15" = True
isClosureAllocator "h$c16" = True
isClosureAllocator "h$c17" = True
isClosureAllocator "h$c18" = True
isClosureAllocator "h$c19" = True
isClosureAllocator "h$c20" = True
isClosureAllocator "h$c21" = True
isClosureAllocator "h$c22" = True
isClosureAllocator "h$c23" = True
isClosureAllocator "h$c24" = True
isClosureAllocator _ = False