quox/lib/Quox/Parser/FromParser/Error.idr

module Quox.Parser.FromParser.Error

import Quox.Parser.Parser
import Quox.Typing
import System.File

import Quox.Pretty

%hide Text.PrettyPrint.Prettyprinter.Doc.infixr.(<++>)


public export
TypeError, LexError, ParseError : Type
TypeError = Typing.Error
LexError = Lexer.Error
ParseError = Parser.Error
%hide Typing.Error
%hide Lexer.Error
%hide Parser.Error

public export
data Error =
    AnnotationNeeded Loc (NameContexts d n) (Term d n)
  | DuplicatesInEnum Loc (List TagVal)
  | TermNotInScope Loc Name
  | DimNotInScope Loc PBaseName
  | QtyNotGlobal Loc Qty
  | DimNameInTerm Loc PBaseName
  | DisplacedBoundVar Loc PName
  | WrapTypeError TypeError
  | LoadError Loc String FileError
  | WrapParseError String ParseError


export
prettyLexError : {opts : _} -> String -> LexError -> Eff Pretty (Doc opts)
prettyLexError file (Err reason line col char) = do
  let loc = makeLoc file (MkBounds line col line col)
  reason <- case reason of
    EndInput    => pure "unexpected end of input"
    NoRuleApply => pure $ text "unrecognised character: \{show char}"
    ComposeNotClosing (sl, sc) (el, ec) => pure $
      hsep ["unterminated token at", !(prettyBounds (MkBounds sl sc el ec))]
  pure $ vappend !(prettyLoc loc) reason

export
prettyParseError1 : {opts : _} -> String -> ParsingError _ ->
                    Eff Pretty (Doc opts)
prettyParseError1 file (Error msg Nothing) =
  pure $ text msg
prettyParseError1 file (Error msg (Just bounds)) =
  pure $ vappend !(prettyLoc $ makeLoc file bounds) (text msg)

export
prettyParseError : {opts : _} -> String -> ParseError ->
                   Eff Pretty (Doc opts)
prettyParseError file (LexError err) =
  pure $ vsep ["lexical error:", !(prettyLexError file err)]
prettyParseError file (ParseError errs) =
  map (vsep . ("parse error:" ::)) $
    traverse (map ("-" <++>) . prettyParseError1 file) (toList errs)


parameters (showContext : Bool)
  export
  prettyError : {opts : _} -> Error -> Eff Pretty (Doc opts)
  prettyError (AnnotationNeeded loc ctx tm) =
    [|vappend (prettyLoc loc)
        (hangD "type annotation needed on"
               !(prettyTerm ctx.dnames ctx.tnames tm))|]
    -- [todo] print the original PTerm instead

  prettyError (DuplicatesInEnum loc tags) =
    [|vappend (prettyLoc loc)
        (hangD "duplicate tags in enum type" !(prettyEnum tags))|]

  prettyError (DimNotInScope loc i) =
    [|vappend (prettyLoc loc)
        (pure $ hsep ["dimension", !(hl DVar $ text i), "not in scope"])|]

  prettyError (TermNotInScope loc x) =
    [|vappend (prettyLoc loc)
        (pure $ hsep ["term variable", !(prettyFree x), "not in scope"])|]

  prettyError (QtyNotGlobal loc pi) = pure $
    vappend !(prettyLoc loc)
      (sep ["quantity" <++> !(prettyQty pi),
            "can't be used on a top level declaration"])

  prettyError (DimNameInTerm loc i) = pure $
    vappend !(prettyLoc loc)
      (sep ["dimension" <++> !(hl DVar $ text i),
            "used in a term context"])

  prettyError (DisplacedBoundVar loc x) = pure $
    vappend !(prettyLoc loc)
      (sep ["local variable" <++> !(hl TVar $ text $ toDotsP x),
            "cannot be displaced"])

  prettyError (WrapTypeError err) =
    Typing.prettyError showContext $ trimContext 2 err

  prettyError (LoadError loc str err) = pure $
    vsep [!(prettyLoc loc),
          "couldn't load file" <++> text str,
          text $ show err]

  prettyError (WrapParseError file err) =
    prettyParseError file err