Language.Haskell.Liquid.Types.PrettyPrint

This module contains a single function that converts a RType -> Doc without using *any* simplifications.

Printable RTypes

type OkRT c tv r = (TyConable c, PPrint tv, PPrint c, PPrint r, Reftable r, Reftable (RTProp c tv ()), Reftable (RTProp c tv r), Eq c, Eq tv, Hashable tv)

Printers

rtypeDoc :: OkRT c tv r => Tidy -> RType c tv r -> Doc

Printing Lists (TODO: move to fixpoint)

pprManyOrdered :: (PPrint a, Ord a) => Tidy -> String -> [a] -> [Doc]

pprintLongList :: PPrint a => Tidy -> [a] -> Doc

pprintSymbol :: Symbol -> Doc

Printing diagnostics

printWarning :: Logger -> DynFlags -> Warning -> IO ()

Printing Warnings ---------------------------------------------------------

Filtering errors

data Filter

Filters match errors. They are used to ignore classes of errors they match. AnyFilter matches all errors. StringFilter matches any error whose "representation" contains the given String. A "representation" is pretty-printed String of the error.

Constructors

StringFilter String

AnyFilter

Instances

Show Filter

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

showsPrec :: Int -> Filter -> ShowS

show :: Filter -> String

showList :: [Filter] -> ShowS

Eq Filter

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

(==) :: Filter -> Filter -> Bool

(/=) :: Filter -> Filter -> Bool

Ord Filter

Defined in Language.Haskell.Liquid.Types.PrettyPrint

Methods

compare :: Filter -> Filter -> Ordering

(<) :: Filter -> Filter -> Bool

(<=) :: Filter -> Filter -> Bool

(>) :: Filter -> Filter -> Bool

(>=) :: Filter -> Filter -> Bool

max :: Filter -> Filter -> Filter

min :: Filter -> Filter -> Filter

getFilters :: Config -> [Filter]

Retrieve the Filters from the Config.

reduceFilters :: (e -> String) -> [Filter] -> e -> [Filter]

Return the list of filters that matched the err , given a renderer for the err and some filters

defaultFilterReporter :: FilePath -> [Filter] -> TcRn ()

Report errors via GHC's API stating the given Filters did not get matched. Does nothing if the list of filters is empty.

Reporting errors in the typechecking phase

data FilterReportErrorsArgs m filter msg e a

Used in filterReportErrorsWith`

Constructors

FilterReportErrorsArgs

Fields

• msgReporter :: [msg] -> m ()

  Report the msgs to the monad (usually IO)

• filterReporter :: [filter] -> m ()

  Report unmatched filters to the monad

• failure :: m a

  Continuation for when there are unmatched filters or unmatched errors

• continue :: m a

  Continuation for when there are no unmatched errors or filters

• pprinter :: e -> m msg

  Compute a representation of the given error; does not report the error

• matchingFilters :: e -> [filter]

  Yields the filters that map a given error. Must only yield filters in the filters field.

• filters :: [filter]

  List of filters which could have been matched

filterReportErrorsWith :: (Monad m, Ord filter) => FilterReportErrorsArgs m filter msg e a -> [e] -> m a

Calls the continuations in FilterReportErrorsArgs depending on whethere there are unmatched errors, unmatched filters or none.

filterReportErrors :: forall e' a. (Show e', PPrint e') => FilePath -> TcRn a -> TcRn a -> [Filter] -> Tidy -> [TError e'] -> TcRn a

Pretty-printing errors ----------------------------------------------------

Similar in spirit to reportErrors from the GHC API, but it uses our pretty-printer and shim functions under the hood. Also filters the errors according to the given Filter list.

filterReportErrors failure continue filters k will call failure if there are unexpected errors, or will call continue otherwise.

An error is expected if there is any filter that matches it.

Orphan instances

Show Predicate

Methods

showsPrec :: Int -> Predicate -> ShowS

show :: Predicate -> String

showList :: [Predicate] -> ShowS

PPrint Class

Methods

pprintTidy :: Tidy -> Class -> Doc

pprintPrec :: Int -> Tidy -> Class -> Doc

PPrint Type

Methods

pprintTidy :: Tidy -> Type -> Doc

pprintPrec :: Int -> Tidy -> Type -> Doc

PPrint TyCon

Methods

pprintTidy :: Tidy -> TyCon -> Doc

pprintPrec :: Int -> Tidy -> TyCon -> Doc

PPrint Name

Methods

pprintTidy :: Tidy -> Name -> Doc

pprintPrec :: Int -> Tidy -> Name -> Doc

PPrint SourceError

Methods

pprintTidy :: Tidy -> SourceError -> Doc

pprintPrec :: Int -> Tidy -> SourceError -> Doc

PPrint Var

Methods

pprintTidy :: Tidy -> Var -> Doc

pprintPrec :: Int -> Tidy -> Var -> Doc

PPrint Tidy

Methods

pprintTidy :: Tidy -> Tidy -> Doc

pprintPrec :: Int -> Tidy -> Tidy -> Doc

PPrint LMap

Methods

pprintTidy :: Tidy -> LMap -> Doc

pprintPrec :: Int -> Tidy -> LMap -> Doc

PPrint LogicMap

Methods

pprintTidy :: Tidy -> LogicMap -> Doc

pprintPrec :: Int -> Tidy -> LogicMap -> Doc

PPrint a => Show (AnnInfo a)

Methods

showsPrec :: Int -> AnnInfo a -> ShowS

show :: AnnInfo a -> String

showList :: [AnnInfo a] -> ShowS

PPrint (Bind Var)

Methods

pprintTidy :: Tidy -> Bind Var -> Doc

pprintPrec :: Int -> Tidy -> Bind Var -> Doc

PPrint (Expr Var)

Methods

pprintTidy :: Tidy -> Expr Var -> Doc

pprintPrec :: Int -> Tidy -> Expr Var -> Doc

PPrint (MsgEnvelope DecoratedSDoc)

A whole bunch of PPrint instances follow ----------------------------------

Methods

pprintTidy :: Tidy -> MsgEnvelope DecoratedSDoc -> Doc

pprintPrec :: Int -> Tidy -> MsgEnvelope DecoratedSDoc -> Doc

PPrint a => PPrint (AnnInfo a)

Methods

pprintTidy :: Tidy -> AnnInfo a -> Doc

pprintPrec :: Int -> Tidy -> AnnInfo a -> Doc

PPrint t => PPrint (Annot t)

Methods

pprintTidy :: Tidy -> Annot t -> Doc

pprintPrec :: Int -> Tidy -> Annot t -> Doc

(PPrint r, Reftable r) => PPrint (UReft r)

Methods

pprintTidy :: Tidy -> UReft r -> Doc

pprintPrec :: Int -> Tidy -> UReft r -> Doc

(PPrint tv, PPrint ty) => PPrint (RTAlias tv ty)

Methods

pprintTidy :: Tidy -> RTAlias tv ty -> Doc

pprintPrec :: Int -> Tidy -> RTAlias tv ty -> Doc

(PPrint tv, PPrint t) => PPrint (RTEnv tv t)

Methods

pprintTidy :: Tidy -> RTEnv tv t -> Doc

pprintPrec :: Int -> Tidy -> RTEnv tv t -> Doc

OkRT c tv r => PPrint (RType c tv r)

Pretty Printing RefType ---------------------------------------------------

Methods

pprintTidy :: Tidy -> RType c tv r -> Doc

pprintPrec :: Int -> Tidy -> RType c tv r -> Doc