{-# language CPP #-}
{-# language AllowAmbiguousTypes #-}
{-# language ConstraintKinds #-}
{-# language MultiWayIf #-}
{-# language TypeFamilies #-}


-- | Code for rendering/representation of the messages packaged with their context (Frames).
module Nix.Render.Frame where

import           Nix.Prelude         hiding ( Comparison )
import           GHC.Exception              ( ErrorCall )
import           Data.Fix                   ( Fix(..) )
import           Nix.Eval            hiding ( addMetaInfo )
import           Nix.Exec
import           Nix.Expr.Types
import           Nix.Expr.Types.Annotated
import           Nix.Frames
import           Nix.Normal
import           Nix.Options
import           Nix.Pretty
import           Nix.Render
import           Nix.Thunk
import           Nix.Value
import           Prettyprinter       hiding ( list )
import qualified Text.Show                 as Text
import           Text.Megaparsec.Pos        ( sourcePosPretty)
import qualified Text.Show.Pretty          as PS

renderFrames
  :: forall v t f e m ann
   . ( MonadReader e m
     , Has e Options
     , MonadFile m
     , MonadCitedThunks t f m
     , Typeable v
     )
  => Frames
  -> m (Doc ann)
renderFrames :: forall v t (f :: * -> *) e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m, Typeable v) =>
Frames -> m (Doc ann)
renderFrames []       = forall (f :: * -> *) a. (Applicative f, Monoid a) => f a
stub
renderFrames xss :: Frames
xss@(NixFrame
x : Frames
xs) =
  do
    Options
opts <- forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
    let
      verbosity :: Verbosity
      verbosity :: Verbosity
verbosity = Options -> Verbosity
getVerbosity Options
opts
    [Doc ann]
renderedFrames <- if
        | Verbosity
verbosity forall a. Ord a => a -> a -> Bool
<= Verbosity
ErrorsOnly -> forall ann1. NixFrame -> m [Doc ann1]
render1 NixFrame
x
      --  2021-10-22: NOTE: List reverse is completely conterproductive. `reverse` of list famously neest to traverse the whole list to take the last element
        | Verbosity
verbosity forall a. Ord a => a -> a -> Bool
<= Verbosity
Informational -> (forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap NixFrame -> [Doc ann]
renderPosition (forall a. [a] -> [a]
reverse Frames
xs) forall a. Semigroup a => a -> a -> a
<>) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall ann1. NixFrame -> m [Doc ann1]
render1 NixFrame
x
        | Bool
otherwise -> forall b (m :: * -> *) (f :: * -> *) a.
(Monoid b, Monad m, Foldable f) =>
(a -> m b) -> f a -> m b
foldMapM forall ann1. NixFrame -> m [Doc ann1]
render1 (forall a. [a] -> [a]
reverse Frames
xss)
    pure $
      forall (t :: * -> *) b a. Foldable t => b -> (t a -> b) -> t a -> b
handlePresence
        forall a. Monoid a => a
mempty
        forall ann. [Doc ann] -> Doc ann
vsep
        [Doc ann]
renderedFrames
 where
  render1 :: NixFrame -> m [Doc ann1]
  render1 :: forall ann1. NixFrame -> m [Doc ann1]
render1 = forall v t (f :: * -> *) e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m, Typeable v) =>
NixFrame -> m [Doc ann]
renderFrame @v @t @f

  renderPosition :: NixFrame -> [Doc ann]
  renderPosition :: NixFrame -> [Doc ann]
renderPosition =
    forall b a. Monoid b => (a -> b) -> Maybe a -> b
whenJust
      (\ NSourcePos
pos -> forall x. One x => OneItem x -> x
one (Doc ann
"While evaluating at " forall a. Semigroup a => a -> a -> a
<> forall a ann. Pretty a => a -> Doc ann
pretty (SourcePos -> String
sourcePosPretty forall a b. (a -> b) -> a -> b
$ NSourcePos -> SourcePos
toSourcePos NSourcePos
pos) forall a. Semigroup a => a -> a -> a
<> forall ann. Doc ann
colon))
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall v (m :: * -> *).
(Typeable m, Typeable v) =>
NixFrame -> Maybe NSourcePos
framePos @v @m

framePos
  :: forall v (m :: Type -> Type)
   . (Typeable m, Typeable v)
  => NixFrame
  -> Maybe NSourcePos
framePos :: forall v (m :: * -> *).
(Typeable m, Typeable v) =>
NixFrame -> Maybe NSourcePos
framePos (NixFrame NixLevel
_ SomeException
f) =
  (\case
    EvaluatingExpr Scopes m v
_ (Ann (SrcSpan NSourcePos
beg NSourcePos
_) NExprF (Ann SrcSpan NExprF)
_) -> forall (f :: * -> *) a. Applicative f => a -> f a
pure NSourcePos
beg
    EvalFrame m v
_ -> forall a. Maybe a
Nothing
  )
  forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e. Exception e => SomeException -> Maybe e
fromException @(EvalFrame m v) SomeException
f

renderFrame
  :: forall v t f e m ann
   . ( MonadReader e m
     , Has e Options
     , MonadFile m
     , MonadCitedThunks t f m
     , Typeable v
     )
  => NixFrame
  -> m [Doc ann]
renderFrame :: forall v t (f :: * -> *) e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m, Typeable v) =>
NixFrame -> m [Doc ann]
renderFrame (NixFrame NixLevel
level SomeException
f)
  | Just (EvalFrame m v
e :: EvalFrame      m v) <- forall e. Exception e => SomeException -> Maybe e
fromException SomeException
f = forall e (m :: * -> *) v ann.
(MonadReader e m, Has e Options, MonadFile m) =>
NixLevel -> EvalFrame m v -> m [Doc ann]
renderEvalFrame  NixLevel
level  EvalFrame m v
e
  | Just (ThunkLoop
e :: ThunkLoop         ) <- forall e. Exception e => SomeException -> Maybe e
fromException SomeException
f = forall e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m, Show (ThunkId m)) =>
NixLevel -> ThunkLoop -> m [Doc ann]
renderThunkLoop  NixLevel
level  ThunkLoop
e
  | Just (ValueFrame t f m
e :: ValueFrame t f m  ) <- forall e. Exception e => SomeException -> Maybe e
fromException SomeException
f = forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> ValueFrame t f m -> m [Doc ann]
renderValueFrame NixLevel
level  ValueFrame t f m
e
  | Just (NormalLoop t f m
e :: NormalLoop t f m  ) <- forall e. Exception e => SomeException -> Maybe e
fromException SomeException
f = forall e (m :: * -> *) t (f :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> NormalLoop t f m -> m [Doc ann]
renderNormalLoop NixLevel
level  NormalLoop t f m
e
  | Just (ExecFrame t f m
e :: ExecFrame  t f m  ) <- forall e. Exception e => SomeException -> Maybe e
fromException SomeException
f = forall e (m :: * -> *) t (f :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> ExecFrame t f m -> m [Doc ann]
renderExecFrame  NixLevel
level  ExecFrame t f m
e
  | Just (ErrorCall
e :: ErrorCall         ) <- forall e. Exception e => SomeException -> Maybe e
fromException SomeException
f = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall x. One x => OneItem x -> x
one forall a b. (a -> b) -> a -> b
$ forall a ann. Pretty a => a -> Doc ann
pretty (forall a. Show a => a -> String
Text.show ErrorCall
e)
  | Just (SynHoleInfo m v
e :: SynHoleInfo    m v) <- forall e. Exception e => SomeException -> Maybe e
fromException SomeException
f = forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall x. One x => OneItem x -> x
one forall a b. (a -> b) -> a -> b
$ forall a ann. Pretty a => a -> Doc ann
pretty (forall a. Show a => a -> String
Text.show SynHoleInfo m v
e)
  | Bool
otherwise = forall (m :: * -> *) a. MonadFail m => String -> m a
fail forall a b. (a -> b) -> a -> b
$ String
"Unrecognized frame: " forall a. Semigroup a => a -> a -> a
<> forall b a. (Show a, IsString b) => a -> b
show SomeException
f

wrapExpr :: NExprF r -> NExpr
wrapExpr :: forall r. NExprF r -> NExpr
wrapExpr NExprF r
x = forall (f :: * -> *). f (Fix f) -> Fix f
Fix (forall (f :: * -> *). f (Fix f) -> Fix f
Fix (forall r. VarName -> NExprF r
NSym VarName
"<?>") forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ NExprF r
x)

renderEvalFrame
  :: forall e m v ann
  . (MonadReader e m, Has e Options, MonadFile m)
  => NixLevel
  -> EvalFrame m v
  -> m [Doc ann]
renderEvalFrame :: forall e (m :: * -> *) v ann.
(MonadReader e m, Has e Options, MonadFile m) =>
NixLevel -> EvalFrame m v -> m [Doc ann]
renderEvalFrame NixLevel
level EvalFrame m v
f =
  do
    Options
opts <- forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
    let
      addMetaInfo :: ([Doc ann] -> [Doc ann]) -> SrcSpan -> Doc ann -> m [Doc ann]
      addMetaInfo :: ([Doc ann] -> [Doc ann]) -> SrcSpan -> Doc ann -> m [Doc ann]
addMetaInfo [Doc ann] -> [Doc ann]
trans SrcSpan
loc = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Doc ann] -> [Doc ann]
trans forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x. One x => OneItem x -> x
one) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *) a.
MonadFile m =>
SrcSpan -> Doc a -> m (Doc a)
renderLocation SrcSpan
loc

    case EvalFrame m v
f of
      EvaluatingExpr Scopes m v
scope e :: Ann SrcSpan NExprF
e@(Ann SrcSpan
loc NExprF (Ann SrcSpan NExprF)
_) ->
        ([Doc ann] -> [Doc ann]) -> SrcSpan -> Doc ann -> m [Doc ann]
addMetaInfo
          ([Doc ann]
scopeInfo forall a. Semigroup a => a -> a -> a
<>)
          SrcSpan
loc
          forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m) =>
NixLevel -> Text -> Text -> Ann SrcSpan NExprF -> m (Doc ann)
renderExpr NixLevel
level Text
"While evaluating" Text
"Expression" Ann SrcSpan NExprF
e
         where
          scopeInfo :: [Doc ann]
          scopeInfo :: [Doc ann]
scopeInfo =
            forall x. One x => OneItem x -> x
one (forall a ann. Pretty a => a -> Doc ann
pretty forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
Text.show Scopes m v
scope) forall a. Monoid a => a -> Bool -> a
`whenTrue` Options -> Bool
isShowScopes Options
opts

      ForcingExpr Scopes m v
_scope e :: Ann SrcSpan NExprF
e@(Ann SrcSpan
loc NExprF (Ann SrcSpan NExprF)
_) | Options -> Bool
isThunks Options
opts ->
        ([Doc ann] -> [Doc ann]) -> SrcSpan -> Doc ann -> m [Doc ann]
addMetaInfo
          forall a. a -> a
id
          SrcSpan
loc
          forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m) =>
NixLevel -> Text -> Text -> Ann SrcSpan NExprF -> m (Doc ann)
renderExpr NixLevel
level Text
"While forcing thunk from" Text
"Forcing thunk" Ann SrcSpan NExprF
e

      Calling VarName
name SrcSpan
loc ->
        ([Doc ann] -> [Doc ann]) -> SrcSpan -> Doc ann -> m [Doc ann]
addMetaInfo
          forall a. a -> a
id
          SrcSpan
loc
          forall a b. (a -> b) -> a -> b
$ Doc ann
"While calling `builtins." forall a. Semigroup a => a -> a -> a
<> forall ann. VarName -> Doc ann
prettyVarName VarName
name forall a. Semigroup a => a -> a -> a
<> Doc ann
"`"

      SynHole SynHoleInfo m v
synfo ->
        forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
sequenceA
          [ forall (m :: * -> *) a.
MonadFile m =>
SrcSpan -> Doc a -> m (Doc a)
renderLocation SrcSpan
loc forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<<
              forall e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m) =>
NixLevel -> Text -> Text -> Ann SrcSpan NExprF -> m (Doc ann)
renderExpr NixLevel
level Text
"While evaluating" Text
"Syntactic Hole" Ann SrcSpan NExprF
e
          , forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a ann. Pretty a => a -> Doc ann
pretty forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
Text.show forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) v. SynHoleInfo m v -> Scopes m v
_synHoleInfo_scope SynHoleInfo m v
synfo
          ]
         where
          e :: Ann SrcSpan NExprF
e@(Ann SrcSpan
loc NExprF (Ann SrcSpan NExprF)
_) = forall (m :: * -> *) v. SynHoleInfo m v -> Ann SrcSpan NExprF
_synHoleInfo_expr SynHoleInfo m v
synfo

      ForcingExpr Scopes m v
_ Ann SrcSpan NExprF
_ -> forall (f :: * -> *) a. (Applicative f, Monoid a) => f a
stub


renderExpr
  :: (MonadReader e m, Has e Options, MonadFile m)
  => NixLevel
  -> Text
  -> Text
  -> NExprLoc
  -> m (Doc ann)
renderExpr :: forall e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m) =>
NixLevel -> Text -> Text -> Ann SrcSpan NExprF -> m (Doc ann)
renderExpr NixLevel
_level Text
longLabel Text
shortLabel e :: Ann SrcSpan NExprF
e@(Ann SrcSpan
_ NExprF (Ann SrcSpan NExprF)
x) =
  do
    Options
opts <- forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
    let
      verbosity :: Verbosity
      verbosity :: Verbosity
verbosity = Options -> Verbosity
getVerbosity Options
opts

      expr :: NExpr
      expr :: NExpr
expr = forall (f :: * -> *) ann. Functor f => Ann ann f -> Fix f
stripAnnotation Ann SrcSpan NExprF
e

      concise :: Doc ann
concise = forall ann. NExpr -> Doc ann
prettyNix forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *). f (Fix f) -> Fix f
Fix forall a b. (a -> b) -> a -> b
$ forall (f :: * -> *). f (Fix f) -> Fix f
Fix (forall r. VarName -> NExprF r
NSym VarName
"<?>") forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ NExprF (Ann SrcSpan NExprF)
x

      chatty :: Doc ann
chatty =
        forall a. a -> a -> Bool -> a
bool
          (forall a ann. Pretty a => a -> Doc ann
pretty forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> String
PS.ppShow NExpr
expr)
          (forall ann. NExpr -> Doc ann
prettyNix NExpr
expr)
          (Verbosity
verbosity forall a. Eq a => a -> a -> Bool
== Verbosity
Chatty)

    forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
      forall a. a -> a -> Bool -> a
bool
        (forall a ann. Pretty a => a -> Doc ann
pretty Text
shortLabel forall a. Semigroup a => a -> a -> a
<> forall ann. [Doc ann] -> Doc ann
fillSep [Doc ann
": ", Doc ann
concise])
        (forall ann. [Doc ann] -> Doc ann
vsep [forall a ann. Pretty a => a -> Doc ann
pretty (Text
longLabel forall a. Semigroup a => a -> a -> a
<> Text
":\n>>>>>>>>"), forall ann. Int -> Doc ann -> Doc ann
indent Int
2 forall ann. Doc ann
chatty, Doc ann
"<<<<<<<<"])
        (Verbosity
verbosity forall a. Ord a => a -> a -> Bool
>= Verbosity
Chatty)

renderValueFrame
  :: forall e t f m ann
   . (MonadReader e m, Has e Options, MonadFile m, MonadCitedThunks t f m)
  => NixLevel
  -> ValueFrame t f m
  -> m [Doc ann]
renderValueFrame :: forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> ValueFrame t f m -> m [Doc ann]
renderValueFrame NixLevel
level = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall x. One x => OneItem x -> x
one forall b c a. (b -> c) -> (a -> b) -> a -> c
. \case
  ForcingThunk    t
_t -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Doc ann
"ForcingThunk" -- jww (2019-03-18): NYI
  ConcerningValue NValue t f m
_v -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Doc ann
"ConcerningValue"
  Comparison     NValue t f m
_ NValue t f m
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Doc ann
"Comparing"
  Addition       NValue t f m
_ NValue t f m
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Doc ann
"Adding"
  Division       NValue t f m
_ NValue t f m
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Doc ann
"Dividing"
  Multiplication NValue t f m
_ NValue t f m
_ -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Doc ann
"Multiplying"

  Coercion       ValueType
x ValueType
y -> forall (f :: * -> *) a. Applicative f => a -> f a
pure
    forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold [Doc ann
desc, forall a ann. Pretty a => a -> Doc ann
pretty (ValueType -> Text
describeValue ValueType
x), Doc ann
" to ", forall a ann. Pretty a => a -> Doc ann
pretty (ValueType -> Text
describeValue ValueType
y)]
   where
    desc :: Doc ann
desc =
      forall a. a -> a -> Bool -> a
bool
        Doc ann
"While coercing "
        Doc ann
"Cannot coerce "
        (NixLevel
level forall a. Ord a => a -> a -> Bool
<= NixLevel
Error)

  CoercionToJson NValue t f m
v ->
    (Doc ann
"CoercionToJson " forall a. Semigroup a => a -> a -> a
<>) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NValue t f m -> m (Doc ann)
dumbRenderValue NValue t f m
v
  CoercionFromJson Value
_j -> forall (f :: * -> *) a. Applicative f => a -> f a
pure Doc ann
"CoercionFromJson"
  Expectation ValueType
t NValue t f m
v     ->
    (Doc ann
msg forall a. Semigroup a => a -> a -> a
<>) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NValue t f m -> m (Doc ann)
dumbRenderValue NValue t f m
v
   where
    msg :: Doc ann
msg = Doc ann
"Expected " forall a. Semigroup a => a -> a -> a
<> forall a ann. Pretty a => a -> Doc ann
pretty (ValueType -> Text
describeValue ValueType
t) forall a. Semigroup a => a -> a -> a
<> Doc ann
", but saw "

--  2021-10-28: NOTE: notice it ignores `level`, `longlabel` & `shortlabel`, to underline that `dumbRenderValue` synonym was created
renderValue
  :: forall e t f m ann
   . (MonadReader e m, Has e Options, MonadFile m, MonadCitedThunks t f m)
  => NixLevel
  -> Text
  -> Text
  -> NValue t f m
  -> m (Doc ann)
renderValue :: forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> Text -> Text -> NValue t f m -> m (Doc ann)
renderValue NixLevel
_level Text
_longLabel Text
_shortLabel NValue t f m
v =
  do
    Options
opts <- forall e (m :: * -> *).
(MonadReader e m, Has e Options) =>
m Options
askOptions
    forall a. a -> a -> Bool -> a
bool
      forall t (f :: * -> *) (m :: * -> *) ann.
MonadDataContext f m =>
NValue t f m -> Doc ann
prettyNValue
      forall t (f :: * -> *) (m :: * -> *) ann.
(HasCitations m (NValue t f m) t, HasCitations1 m (NValue t f m) f,
 MonadThunk t m (NValue t f m), MonadDataContext f m) =>
NValue t f m -> Doc ann
prettyNValueProv
      (Options -> Bool
isValues Options
opts)
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall t (m :: * -> *) (f :: * -> *).
(MonadThunk t m (NValue t f m), MonadDataContext f m) =>
NValue t f m -> m (NValue t f m)
removeEffects NValue t f m
v

dumbRenderValue
  :: forall e t f m ann
   . (MonadReader e m, Has e Options, MonadFile m, MonadCitedThunks t f m)
   => (NValue t f m -> m (Doc ann))
dumbRenderValue :: forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NValue t f m -> m (Doc ann)
dumbRenderValue = forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> Text -> Text -> NValue t f m -> m (Doc ann)
renderValue NixLevel
Info forall a. Monoid a => a
mempty forall a. Monoid a => a
mempty

renderExecFrame
  :: (MonadReader e m, Has e Options, MonadFile m, MonadCitedThunks t f m)
  => NixLevel
  -> ExecFrame t f m
  -> m [Doc ann]
renderExecFrame :: forall e (m :: * -> *) t (f :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> ExecFrame t f m -> m [Doc ann]
renderExecFrame NixLevel
_level (Assertion SrcSpan
ann NValue t f m
v) =
  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
    forall x. One x => OneItem x -> x
one
    forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
MonadFile m =>
SrcSpan -> Doc a -> m (Doc a)
renderLocation SrcSpan
ann forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall ann. [Doc ann] -> Doc ann
fillSep forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
on forall a. Semigroup a => a -> a -> a
(<>) forall x. One x => OneItem x -> x
one Doc ann
"Assertion failed:" forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NValue t f m -> m (Doc ann)
dumbRenderValue NValue t f m
v

renderThunkLoop
  :: (MonadReader e m, Has e Options, MonadFile m, Show (ThunkId m))
  => NixLevel
  -> ThunkLoop
  -> m [Doc ann]
renderThunkLoop :: forall e (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m, Show (ThunkId m)) =>
NixLevel -> ThunkLoop -> m [Doc ann]
renderThunkLoop NixLevel
_level (ThunkLoop Text
n) =
  forall (f :: * -> *) a. Applicative f => a -> f a
pure forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x. One x => OneItem x -> x
one forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a ann. Pretty a => a -> Doc ann
pretty forall a b. (a -> b) -> a -> b
$ Text
"Infinite recursion in thunk " forall a. Semigroup a => a -> a -> a
<> Text
n

renderNormalLoop
  :: (MonadReader e m, Has e Options, MonadFile m, MonadCitedThunks t f m)
  => NixLevel
  -> NormalLoop t f m
  -> m [Doc ann]
renderNormalLoop :: forall e (m :: * -> *) t (f :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NixLevel -> NormalLoop t f m -> m [Doc ann]
renderNormalLoop NixLevel
_level (NormalLoop NValue t f m
v) =
  forall x. One x => OneItem x -> x
one forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Doc ann
"Infinite recursion during normalization forcing " forall a. Semigroup a => a -> a -> a
<>) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall e t (f :: * -> *) (m :: * -> *) ann.
(MonadReader e m, Has e Options, MonadFile m,
 MonadCitedThunks t f m) =>
NValue t f m -> m (Doc ann)
dumbRenderValue NValue t f m
v