%
+% (c) The University of Glasgow 2006
% (c) The GRASP/AQUA Project, Glasgow University, 1997-1998
%
\section[BasicTypes]{Miscellanous types}
\end{itemize}
\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 BasicTypes(
Version, bumpVersion, initialVersion,
TupCon(..), tupleParens,
OccInfo(..), seqOccInfo, isFragileOcc, isOneOcc,
- isDeadOcc, isLoopBreaker, isNoOcc,
+ isDeadOcc, isLoopBreaker, isNonRuleLoopBreaker, isNoOcc,
InsideLam, insideLam, notInsideLam,
OneBranch, oneBranch, notOneBranch,
early in the hierarchy), but also in HsSyn.
\begin{code}
-data IPName name
- = Dupable name -- ?x: you can freely duplicate this implicit parameter
- | Linear name -- %x: you must use the splitting function to duplicate it
+newtype IPName name = IPName name -- ?x
deriving( Eq, Ord ) -- Ord is used in the IP name cache finite map
-- (used in HscTypes.OrigIParamCache)
-
ipNameName :: IPName name -> name
-ipNameName (Dupable n) = n
-ipNameName (Linear n) = n
+ipNameName (IPName n) = n
mapIPName :: (a->b) -> IPName a -> IPName b
-mapIPName f (Dupable n) = Dupable (f n)
-mapIPName f (Linear n) = Linear (f n)
+mapIPName f (IPName n) = IPName (f n)
instance Outputable name => Outputable (IPName name) where
- ppr (Dupable n) = char '?' <> ppr n -- Ordinary implicit parameters
- ppr (Linear n) = char '%' <> ppr n -- Splittable implicit parameters
+ ppr (IPName n) = char '?' <> ppr n -- Ordinary implicit parameters
\end{code}
%* *
%************************************************************************
-\begin{code}
+\begin{code}
data RecFlag = Recursive
| NonRecursive
deriving( Eq )
-- Without the Incoherent flag, we'd complain that
-- instantiating 'b' would change which instance
-- was chosen
+ deriving( Eq )
instance Outputable OverlapFlag where
ppr NoOverlap = empty
\begin{code}
data OccInfo
- = NoOccInfo
+ = NoOccInfo -- Many occurrences, or unknown
| IAmDead -- Marks unused variables. Sometimes useful for
-- lambda and case-bound variables.
- | OneOcc !InsideLam
- !OneBranch
- !InterestingCxt
+ | OneOcc -- Occurs exactly once, not inside a rule
+ !InsideLam
+ !OneBranch
+ !InterestingCxt
| IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers
-- in a group of recursive definitions
+ !RulesOnly -- True <=> This is a weak or rules-only loop breaker
+ -- See OccurAnal Note [Weak loop breakers]
+
+type RulesOnly = Bool
+\end{code}
+
+\begin{code}
isNoOcc :: OccInfo -> Bool
isNoOcc NoOccInfo = True
isNoOcc other = False
notOneBranch = False
isLoopBreaker :: OccInfo -> Bool
-isLoopBreaker IAmALoopBreaker = True
-isLoopBreaker other = False
+isLoopBreaker (IAmALoopBreaker _) = True
+isLoopBreaker other = False
+
+isNonRuleLoopBreaker :: OccInfo -> Bool
+isNonRuleLoopBreaker (IAmALoopBreaker False) = True -- Loop-breaker that breaks a non-rule cycle
+isNonRuleLoopBreaker other = False
isDeadOcc :: OccInfo -> Bool
isDeadOcc IAmDead = True
\begin{code}
instance Outputable OccInfo where
-- only used for debugging; never parsed. KSW 1999-07
- ppr NoOccInfo = empty
- ppr IAmALoopBreaker = ptext SLIT("LoopBreaker")
- ppr IAmDead = ptext SLIT("Dead")
+ ppr NoOccInfo = empty
+ ppr (IAmALoopBreaker ro) = ptext SLIT("LoopBreaker") <> if ro then char '!' else empty
+ ppr IAmDead = ptext SLIT("Dead")
ppr (OneOcc inside_lam one_branch int_cxt)
= ptext SLIT("Once") <> pp_lam <> pp_br <> pp_args
where
\begin{code}
data SuccessFlag = Succeeded | Failed
+instance Outputable SuccessFlag where
+ ppr Succeeded = ptext SLIT("Succeeded")
+ ppr Failed = ptext SLIT("Failed")
+
successIf :: Bool -> SuccessFlag
successIf True = Succeeded
successIf False = Failed
neverInlineSpec = Inline NeverActive False -- NOINLINE
instance Outputable Activation where
- ppr AlwaysActive = empty -- The default
+ ppr NeverActive = ptext SLIT("NEVER")
+ ppr AlwaysActive = ptext SLIT("ALWAYS")
ppr (ActiveBefore n) = brackets (char '~' <> int n)
ppr (ActiveAfter n) = brackets (int n)
- ppr NeverActive = ptext SLIT("NEVER")
instance Outputable InlineSpec where
- ppr (Inline act True) = ptext SLIT("INLINE") <> ppr act
- ppr (Inline act False) = ptext SLIT("NOINLINE") <> ppr act
+ ppr (Inline act is_inline)
+ | is_inline = ptext SLIT("INLINE")
+ <> case act of
+ AlwaysActive -> empty
+ other -> ppr act
+ | otherwise = ptext SLIT("NOINLINE")
+ <> case act of
+ NeverActive -> empty
+ other -> ppr act
isActive :: CompilerPhase -> Activation -> Bool
isActive p NeverActive = False