{- -----------------------------------------------------------------------------
Copyright 2020-2021 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# LANGUAGE Safe #-}

module Test.TrackedErrors (tests) where

import Control.Arrow (first)
import Control.Monad.Writer

import Base.CompilerError
import Base.TrackedErrors


tests :: [IO (TrackedErrors ())]
tests :: [IO (TrackedErrors ())]
tests = [
    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    String -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"error\n" (String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" :: TrackedErrorsIO Char),
    String -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"" (TrackedErrorsIO Char
forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM :: TrackedErrorsIO Char),

    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char
'a',Char
'b']          ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess []                 ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [] :: TrackedErrorsIO [Char]),
    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   String
"error1\nerror2\n" ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error1",Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error2"]),

    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess String
"ab" ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess String
""   ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [] :: TrackedErrorsIO [Char]),
    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess String
"b"  ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error1",Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error2"]),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' ([TrackedErrorsIO Char] -> TrackedErrorsIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   String
""  ([TrackedErrorsIO Char] -> TrackedErrorsIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [] :: TrackedErrorsIO Char),
    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'b' ([TrackedErrorsIO Char] -> TrackedErrorsIO Char
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error1",Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error2"]),

    String -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings String
"warning1\nwarning2\n" ()
      (String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning1" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrorsIO ()
forall (m :: * -> *) a. Monad m => a -> m a
return () TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning2"),
    String -> String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings String
"warning1\n" String
"error\n"
      (String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning1" TrackedErrorsIO ()
-> TrackedErrorsT IO Any -> TrackedErrorsT IO Any
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsT IO Any
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" TrackedErrorsT IO Any -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning2" :: TrackedErrorsIO ()),

    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char
'a',Char
'b']  ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess []         ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [] :: TrackedErrorsIO [Char]),
    String -> TrackedErrorsIO String -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   String
"error1\n" ([TrackedErrorsIO Char] -> TrackedErrorsIO String
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error1",Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error2"]),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' TrackedErrorsIO Char -> String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`withContextM` String
"message"),
    String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"message\n  error\n" (String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`withContextM` String
"message" :: TrackedErrorsIO ()),
    String -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings String
"message\n  warning\n" ()
      (String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning" TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`withContextM` String
"message" :: TrackedErrorsIO ()),
    String -> String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings String
"message\n  warning\n" String
"message\n  error\n"
      ((String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error") TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`withContextM` String
"message" :: TrackedErrorsIO ()),
    String -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings String
"" () (() -> TrackedErrorsIO ()
forall (m :: * -> *) a. Monad m => a -> m a
return () TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`withContextM` String
"message"),
    String -> String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings String
"" String
"message\n" (TrackedErrorsIO ()
forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`withContextM` String
"message" :: TrackedErrorsIO ()),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' TrackedErrorsIO Char -> String -> TrackedErrorsIO Char
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`summarizeErrorsM` String
"message"),
    String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"message\n  error\n" (String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: TrackedErrorsIO ()),
    String -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings String
"warning\n" ()
      (String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning" TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: TrackedErrorsIO ()),
    String -> String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings String
"warning\n" String
"message\n  error\n"
      ((String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error") TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: TrackedErrorsIO ()),
    String -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings String
"" () (() -> TrackedErrorsIO ()
forall (m :: * -> *) a. Monad m => a -> m a
return () TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`summarizeErrorsM` String
"message"),
    String -> String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings String
"" String
"message\n" (TrackedErrorsIO ()
forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM TrackedErrorsIO () -> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> String -> m a
`summarizeErrorsM` String
"message" :: TrackedErrorsIO ()),

    String -> () -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings String
"error\n" ()
      (TrackedErrors Any -> TrackedErrorsIO ()
forall (m :: * -> *) a.
Monad m =>
TrackedErrors a -> TrackedErrorsT m ()
asCompilerWarnings (TrackedErrors Any -> TrackedErrorsIO ())
-> TrackedErrors Any -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors Any
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" :: TrackedErrorsIO ()),
    String -> String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings String
"" String
"warning\n"
      (TrackedErrors () -> TrackedErrorsIO ()
forall (m :: * -> *) a.
Monad m =>
TrackedErrors a -> TrackedErrorsT m ()
asCompilerError (TrackedErrors () -> TrackedErrorsIO ())
-> TrackedErrors () -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerWarningM String
"warning" :: TrackedErrorsIO ()),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerBackgroundM String
"background" TrackedErrorsIO () -> TrackedErrorsIO Char -> TrackedErrorsIO Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"error\n  background\n"
      (String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerBackgroundM String
"background" TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" :: TrackedErrorsIO ()),
    String -> TrackedErrorsIO [()] -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"error\n  background\n"
      ([TrackedErrorsIO ()] -> TrackedErrorsIO [()]
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerBackgroundM String
"background"] TrackedErrorsIO [()]
-> TrackedErrorsIO [()] -> TrackedErrorsIO [()]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO [()]
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" :: TrackedErrorsIO [()]),
    String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"error\n  background\n"
      ([TrackedErrorsIO ()] -> TrackedErrorsIO ()
forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerBackgroundM String
"background"] TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" :: TrackedErrorsIO ()),

    Char -> TrackedErrorsIO Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' ((TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> m a
resetBackgroundM (TrackedErrorsIO () -> TrackedErrorsIO ())
-> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerBackgroundM String
"background") TrackedErrorsIO () -> TrackedErrorsIO Char -> TrackedErrorsIO Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> TrackedErrorsIO Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    String -> TrackedErrorsIO () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
"error\n"
      ((TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => m a -> m a
resetBackgroundM (TrackedErrorsIO () -> TrackedErrorsIO ())
-> TrackedErrorsIO () -> TrackedErrorsIO ()
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrorsIO ()
forall (m :: * -> *). ErrorContextM m => String -> m ()
compilerBackgroundM String
"background") TrackedErrorsIO () -> TrackedErrorsIO () -> TrackedErrorsIO ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsIO ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"error" :: TrackedErrorsIO ()),

    (Char, String)
-> TrackedErrorsT (Writer String) Char -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
(a, String)
-> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterSuccess (Char
'x',String
"ab") (TrackedErrorsT (Writer String) Char
-> Writer String ()
-> Writer String ()
-> TrackedErrorsT (Writer String) Char
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m () -> m () -> t m a
ifElseSuccessT (Writer String () -> TrackedErrorsT (Writer String) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (String -> Writer String ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell String
"a") TrackedErrorsT (Writer String) ()
-> TrackedErrorsT (Writer String) Char
-> TrackedErrorsT (Writer String) Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> TrackedErrorsT (Writer String) Char
forall (m :: * -> *) a. Monad m => a -> m a
return Char
'x') (String -> Writer String ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell String
"b") (String -> Writer String ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell String
"c")),
    (String, String)
-> TrackedErrorsT (Writer String) () -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
(String, String)
-> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterFail (String
"failed\n",String
"ac") (TrackedErrorsT (Writer String) ()
-> Writer String ()
-> Writer String ()
-> TrackedErrorsT (Writer String) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m () -> m () -> t m a
ifElseSuccessT (Writer String () -> TrackedErrorsT (Writer String) ()
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (String -> Writer String ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell String
"a") TrackedErrorsT (Writer String) ()
-> TrackedErrorsT (Writer String) ()
-> TrackedErrorsT (Writer String) ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> String -> TrackedErrorsT (Writer String) ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM String
"failed") (String -> Writer String ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell String
"b") (String -> Writer String ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell String
"c") :: TrackedErrorsT (Writer String) ())
  ]

checkWriterSuccess :: (Eq a, Show a) => (a,String) -> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterSuccess :: (a, String)
-> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterSuccess (a, String)
x TrackedErrorsT (Writer String) a
y = do
  let (Bool
failed,String
_) = Writer String Bool -> (Bool, String)
forall w a. Writer w a -> (a, w)
runWriter (Writer String Bool -> (Bool, String))
-> Writer String Bool -> (Bool, String)
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer String) a -> Writer String Bool
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m Bool
isCompilerErrorT TrackedErrorsT (Writer String) a
y
  if Bool
failed
     then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ (TrackedErrors (), String) -> TrackedErrors ()
forall a b. (a, b) -> a
fst ((TrackedErrors (), String) -> TrackedErrors ())
-> (TrackedErrors (), String) -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ Writer String (TrackedErrors ()) -> (TrackedErrors (), String)
forall w a. Writer w a -> (a, w)
runWriter (Writer String (TrackedErrors ()) -> (TrackedErrors (), String))
-> Writer String (TrackedErrors ()) -> (TrackedErrors (), String)
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer String) ()
-> Writer String (TrackedErrors ())
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors (TrackedErrorsT (Writer String) ()
 -> Writer String (TrackedErrors ()))
-> TrackedErrorsT (Writer String) ()
-> Writer String (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer String) a
y TrackedErrorsT (Writer String) a
-> TrackedErrorsT (Writer String) ()
-> TrackedErrorsT (Writer String) ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrorsT (Writer String) ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else do
       let y' :: (a, String)
y' = Writer String a -> (a, String)
forall w a. Writer w a -> (a, w)
runWriter (Writer String a -> (a, String)) -> Writer String a -> (a, String)
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer String) a -> Writer String a
forall (m :: * -> *) a. Monad m => TrackedErrorsT m a -> m a
getCompilerSuccessT TrackedErrorsT (Writer String) a
y
       if (a, String)
y' (a, String) -> (a, String) -> Bool
forall a. Eq a => a -> a -> Bool
== (a, String)
x
          then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ () -> TrackedErrors ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ (a, String) -> String
forall a. Show a => a -> String
show (a, String)
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ (a, String) -> String
forall a. Show a => a -> String
show (a, String)
y'

checkWriterFail :: (Eq a, Show a) => (String,String) -> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterFail :: (String, String)
-> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterFail (String, String)
x TrackedErrorsT (Writer String) a
y = do
  let (Bool
failed,String
_) = Writer String Bool -> (Bool, String)
forall w a. Writer w a -> (a, w)
runWriter (Writer String Bool -> (Bool, String))
-> Writer String Bool -> (Bool, String)
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer String) a -> Writer String Bool
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m Bool
isCompilerErrorT TrackedErrorsT (Writer String) a
y
  if Bool
failed
     then do
       let y' :: (String, String)
y' = (CompilerMessage -> String)
-> (CompilerMessage, String) -> (String, String)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first CompilerMessage -> String
forall a. Show a => a -> String
show ((CompilerMessage, String) -> (String, String))
-> (CompilerMessage, String) -> (String, String)
forall a b. (a -> b) -> a -> b
$ Writer String CompilerMessage -> (CompilerMessage, String)
forall w a. Writer w a -> (a, w)
runWriter (Writer String CompilerMessage -> (CompilerMessage, String))
-> Writer String CompilerMessage -> (CompilerMessage, String)
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer String) a -> Writer String CompilerMessage
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m CompilerMessage
getCompilerErrorT TrackedErrorsT (Writer String) a
y
       if (String, String)
y' (String, String) -> (String, String) -> Bool
forall a. Eq a => a -> a -> Bool
== (String, String)
x
          then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ () -> TrackedErrors ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected error " String -> String -> String
forall a. [a] -> [a] -> [a]
++ (String, String) -> String
forall a. Show a => a -> String
show (String, String)
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got error " String -> String -> String
forall a. [a] -> [a] -> [a]
++ (String, String) -> String
forall a. Show a => a -> String
show (String, String)
y'
     else do
       let y' :: (a, String)
y' = Writer String a -> (a, String)
forall w a. Writer w a -> (a, w)
runWriter (Writer String a -> (a, String)) -> Writer String a -> (a, String)
forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer String) a -> Writer String a
forall (m :: * -> *) a. Monad m => TrackedErrorsT m a -> m a
getCompilerSuccessT TrackedErrorsT (Writer String) a
y
       TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected failure but got value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ (a, String) -> String
forall a. Show a => a -> String
show (a, String)
y'

checkSuccess :: (Eq a, Show a) => a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess :: a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess a
x TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  if TrackedErrors a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrors a
y' Bool -> Bool -> Bool
|| TrackedErrors a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y' a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
x
     then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors a
y' TrackedErrors a -> TrackedErrors () -> TrackedErrors ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show a
x String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show (TrackedErrors a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y')

checkError :: (Eq a, Show a) => String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError :: String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
e TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  if Bool -> Bool
not (TrackedErrors a -> Bool
forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrors a
y')
     then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected error \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\" but got value " String -> String -> String
forall a. [a] -> [a] -> [a]
++ a -> String
forall a. Show a => a -> String
show (TrackedErrors a -> a
forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y')
     else if CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrors a
y') String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
e
          then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ () -> TrackedErrors ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected error \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
e String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\" but got error \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrors a
y') String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\""

checkSuccessAndWarnings :: (Eq a, Show a) => String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings :: String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings String
w a
x TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  TrackedErrors ()
outcome <- a -> TrackedErrorsIO a -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess a
x TrackedErrorsIO a
y
  if CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
w
     then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors ()
outcome TrackedErrors () -> TrackedErrors () -> TrackedErrors ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected warnings " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
w String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got warnings \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\""

checkErrorAndWarnings :: (Eq a, Show a) => String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings :: String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings String
w String
e TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- TrackedErrorsIO a -> IO (TrackedErrors a)
forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  TrackedErrors ()
outcome <- String -> TrackedErrorsIO a -> IO (TrackedErrors ())
forall a.
(Eq a, Show a) =>
String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError String
e TrackedErrorsIO a
y
  if CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== String
w
     then TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ TrackedErrors ()
outcome TrackedErrors () -> TrackedErrors () -> TrackedErrors ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> () -> TrackedErrors ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else TrackedErrors () -> IO (TrackedErrors ())
forall (m :: * -> *) a. Monad m => a -> m a
return (TrackedErrors () -> IO (TrackedErrors ()))
-> TrackedErrors () -> IO (TrackedErrors ())
forall a b. (a -> b) -> a -> b
$ String -> TrackedErrors ()
forall (m :: * -> *) a. ErrorContextM m => String -> m a
compilerErrorM (String -> TrackedErrors ()) -> String -> TrackedErrors ()
forall a b. (a -> b) -> a -> b
$ String
"Expected warnings " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
w String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" but got warnings \"" String -> String -> String
forall a. [a] -> [a] -> [a]
++ CompilerMessage -> String
forall a. Show a => a -> String
show (TrackedErrors a -> CompilerMessage
forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"\""