Arity,
- DeprecTxt,
+ WarningTxt(..),
Fixity(..), FixityDirection(..),
defaultFixity, maxPrecedence,
RecFlag(..), isRec, isNonRec, boolToRecFlag,
+ RuleName,
+
TopLevelFlag(..), isTopLevel, isNotTopLevel,
OverlapFlag(..),
SuccessFlag(..), succeeded, failed, successIf
) where
-#include "HsVersions.h"
-
import FastString
import Outputable
\end{code}
\begin{code}
-type DeprecTxt = FastString -- reason/explanation for deprecation
+-- reason/explanation from a WARNING or DEPRECATED pragma
+data WarningTxt = WarningTxt FastString
+ | DeprecatedTxt FastString
+ deriving Eq
+
+instance Outputable WarningTxt where
+ ppr (WarningTxt w) = doubleQuotes (ftext w)
+ ppr (DeprecatedTxt d) = text "Deprecated:" <+> doubleQuotes (ftext d)
\end{code}
%************************************************************************
ppr (IPName n) = char '?' <> ppr n -- Ordinary implicit parameters
\end{code}
+%************************************************************************
+%* *
+ Rules
+%* *
+%************************************************************************
+
+\begin{code}
+type RuleName = FastString
+\end{code}
%************************************************************************
%* *
deriving(Eq)
instance Outputable FixityDirection where
- ppr InfixL = ptext SLIT("infixl")
- ppr InfixR = ptext SLIT("infixr")
- ppr InfixN = ptext SLIT("infix")
+ ppr InfixL = ptext (sLit "infixl")
+ ppr InfixR = ptext (sLit "infixr")
+ ppr InfixN = ptext (sLit "infix")
------------------------
maxPrecedence :: Int
isTopLevel NotTopLevel = False
instance Outputable TopLevelFlag where
- ppr TopLevel = ptext SLIT("<TopLevel>")
- ppr NotTopLevel = ptext SLIT("<NotTopLevel>")
+ ppr TopLevel = ptext (sLit "<TopLevel>")
+ ppr NotTopLevel = ptext (sLit "<NotTopLevel>")
\end{code}
boolToRecFlag False = NonRecursive
instance Outputable RecFlag where
- ppr Recursive = ptext SLIT("Recursive")
- ppr NonRecursive = ptext SLIT("NonRecursive")
+ ppr Recursive = ptext (sLit "Recursive")
+ ppr NonRecursive = ptext (sLit "NonRecursive")
\end{code}
%************************************************************************
instance Outputable OverlapFlag where
ppr NoOverlap = empty
- ppr OverlapOk = ptext SLIT("[overlap ok]")
- ppr Incoherent = ptext SLIT("[incoherent]")
+ ppr OverlapOk = ptext (sLit "[overlap ok]")
+ ppr Incoherent = ptext (sLit "[incoherent]")
\end{code}
tupleParens :: Boxity -> SDoc -> SDoc
tupleParens Boxed p = parens p
-tupleParens Unboxed p = ptext SLIT("(#") <+> p <+> ptext SLIT("#)")
+tupleParens Unboxed p = ptext (sLit "(#") <+> p <+> ptext (sLit "#)")
\end{code}
%************************************************************************
defn of OccInfo here, safely at the bottom
\begin{code}
+-- | Identifier occurrence information
data OccInfo
- = NoOccInfo -- Many occurrences, or unknown
+ = NoOccInfo -- ^ There are many occurrences, or unknown occurences
- | IAmDead -- Marks unused variables. Sometimes useful for
+ | IAmDead -- ^ Marks unused variables. Sometimes useful for
-- lambda and case-bound variables.
- | OneOcc -- Occurs exactly once, not inside a rule
+ | OneOcc
!InsideLam
!OneBranch
- !InterestingCxt
+ !InterestingCxt -- ^ Occurs exactly once, not inside a rule
- | IAmALoopBreaker -- Used by the occurrence analyser to mark loop-breakers
- -- in a group of recursive definitions
+ -- | This identifier breaks a loop of mutually recursive functions. The field
+ -- marks whether it is only a loop breaker due to a reference in a rule
+ | IAmALoopBreaker -- Note [LoopBreaker OccInfo]
!RulesOnly -- True <=> This is a weak or rules-only loop breaker
- -- See OccurAnal Note [Weak loop breakers]
+ -- See OccurAnal Note [Weak loop breakers]
type RulesOnly = Bool
\end{code}
+Note [LoopBreaker OccInfo]
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+An OccInfo of (IAmLoopBreaker False) is used by the occurrence
+analyser in two ways:
+ (a) to mark loop-breakers in a group of recursive
+ definitions (hence the name)
+ (b) to mark binders that must not be inlined in this phase
+ (perhaps it has a NOINLINE pragma)
+Things with (IAmLoopBreaker False) do not get an unfolding
+pinned on to them, so they are completely opaque.
+
+See OccurAnal Note [Weak loop breakers] for (IAmLoopBreaker True).
+
\begin{code}
isNoOcc :: OccInfo -> Bool
instance Outputable OccInfo where
-- only used for debugging; never parsed. KSW 1999-07
ppr NoOccInfo = empty
- ppr (IAmALoopBreaker ro) = ptext SLIT("LoopBreaker") <> if ro then char '!' else empty
- ppr IAmDead = ptext SLIT("Dead")
+ 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
+ = ptext (sLit "Once") <> pp_lam <> pp_br <> pp_args
where
pp_lam | inside_lam = char 'L'
| otherwise = empty
isMarkedStrict _ = True -- All others are strict
instance Outputable StrictnessMark where
- ppr MarkedStrict = ptext SLIT("!")
- ppr MarkedUnboxed = ptext SLIT("!!")
- ppr NotMarkedStrict = ptext SLIT("_")
+ ppr MarkedStrict = ptext (sLit "!")
+ ppr MarkedUnboxed = ptext (sLit "!!")
+ ppr NotMarkedStrict = ptext (sLit "_")
\end{code}
data SuccessFlag = Succeeded | Failed
instance Outputable SuccessFlag where
- ppr Succeeded = ptext SLIT("Succeeded")
- ppr Failed = ptext SLIT("Failed")
+ ppr Succeeded = ptext (sLit "Succeeded")
+ ppr Failed = ptext (sLit "Failed")
successIf :: Bool -> SuccessFlag
successIf True = Succeeded
data InlineSpec
= Inline
Activation -- Says during which phases inlining is allowed
- Bool -- True <=> make the RHS look small, so that when inlining
- -- is enabled, it will definitely actually happen
+ Bool -- True <=> INLINE
+ -- False <=> NOINLINE
deriving( Eq )
defaultInlineSpec, alwaysInlineSpec, neverInlineSpec :: InlineSpec
neverInlineSpec = Inline NeverActive False -- NOINLINE
instance Outputable Activation where
- ppr NeverActive = ptext SLIT("NEVER")
- ppr AlwaysActive = ptext SLIT("ALWAYS")
+ ppr NeverActive = ptext (sLit "NEVER")
+ ppr AlwaysActive = ptext (sLit "ALWAYS")
ppr (ActiveBefore n) = brackets (char '~' <> int n)
ppr (ActiveAfter n) = brackets (int n)
instance Outputable InlineSpec where
ppr (Inline act is_inline)
- | is_inline = ptext SLIT("INLINE")
+ | is_inline = ptext (sLit "INLINE")
<> case act of
AlwaysActive -> empty
_ -> ppr act
- | otherwise = ptext SLIT("NOINLINE")
+ | otherwise = ptext (sLit "NOINLINE")
<> case act of
NeverActive -> empty
_ -> ppr act