packages feed

agda-language-server-11: src/Render/Common.hs

{-# LANGUAGE CPP #-}

module Render.Common where

import Agda.Syntax.Common
  ( Cohesion (..),
    Erased (..),
    Hiding (Hidden, Instance, NotHidden),
    Induction (..),
    LensCohesion (getCohesion),
    LensHiding (getHiding),
    LensQuantity (getQuantity),
    LensRelevance (getRelevance),
    Lock (..),

    LockOrigin (..),

    MetaId (MetaId),
    NameId (..),
    Named (namedThing),
    OverlapMode (..),

    Quantity (..),
    Q0Origin (..),
    Q1Origin (..),
    QωOrigin (..),
    Relevance (..),
    RewriteEqn' (..),
    asQuantity,
#if MIN_VERSION_Agda(2,8,0)
    OriginRelevant (..), 
    OriginIrrelevant (..), 
    OriginShapeIrrelevant (..), 
    PolarityModality (..),
    ModalPolarity (..),
#endif
#if MIN_VERSION_Agda(2,9,0)
    RewriteAnn (..),
#endif
  )
import Agda.Utils.Functor ((<&>))
import Agda.Utils.List1 (toList)
import qualified Agda.Utils.List1 as List1
import qualified Agda.Utils.Null as Agda
import Render.Class
import Render.RichText
import Data.Text (Text)

--------------------------------------------------------------------------------

-- | NameId
instance Render NameId where
  render (NameId n m) = text $ show n ++ "@" ++ show m

-- | MetaId
instance Render MetaId where
  render (MetaId n m) = text $ "_" ++ show n ++ "@" ++ show m

#if MIN_VERSION_Agda(2,8,0)
-- | OriginRelevant
instance Render OriginRelevant where
  render = \case
    ORelInferred {} -> mempty
    ORelRelevant {} -> "@relevant"

instance Render OriginIrrelevant where
  render = \case
    OIrrInferred {} -> mempty
    OIrrDot {} -> "."
    OIrrIrr {} -> "@irr"
    OIrrIrrelevant {} -> "@irrelevant"

instance Render OriginShapeIrrelevant where
  render = \case
    OShIrrInferred {} -> mempty
    OShIrrDotDot {} -> ".."
    OShIrrShIrr {} -> "@shirr"
    OShIrrShapeIrrelevant {} -> "@shape-irrelevant"
#endif

-- | Relevance
#if MIN_VERSION_Agda(2,8,0)
instance Render Relevance where
  render (Relevant o) = render o
  render (Irrelevant o) = Agda.ifNull (render o) "." id
  render (ShapeIrrelevant o) = Agda.ifNull (render o) ".." id
#else
instance Render Relevance where
  render Relevant = mempty
  render Irrelevant = "."
  render NonStrict = ".."
#endif

-- | Quantity
instance Render Quantity where
  render = \case
    Quantity0 o -> let d = render o in if Agda.null d then "@0" else d
    Quantity1 o -> let d = render o in if Agda.null d then "@1" else d
    Quantityω o -> render o

instance Render Q0Origin where
  render = \case
    Q0Inferred -> mempty
    Q0 {} -> "@0"
    Q0Erased {} -> "@erased"

instance Render Q1Origin where
  render = \case
    Q1Inferred -> mempty
    Q1 {} -> "@1"
    Q1Linear {} -> "@linear"

#if MIN_VERSION_Agda(2,9,0)
-- | The @rewrite attribute of a binder
instance Render RewriteAnn where
  render = \case
    IsRewrite _ -> "@rewrite"
    IsNotRewrite -> mempty

#endif
instance Render QωOrigin where
  render = \case
    QωInferred -> mempty
    Qω {} -> "@ω"
    QωPlenty {} -> "@plenty"

instance Render Cohesion where
  render Flat = "@♭"
  render Continuous = mempty
#if MIN_VERSION_Agda(2,9,0)
  render Sharp = "@♯"
#endif
  render Squash = "@⊤"

-- | Polarity

#if MIN_VERSION_Agda(2,8,0)
instance Render ModalPolarity where
  render p = case p of
    UnusedPolarity -> "@unused"
    StrictlyPositive -> "@++"
    Positive -> "@+"
    Negative -> "@-"
    MixedPolarity -> mempty

instance Render PolarityModality where
  render (PolarityModality p _ _) = render p
#endif

--------------------------------------------------------------------------------

instance Render OverlapMode where
  render = \case
    Overlappable -> "OVERLAPPABLE"
    Overlapping -> "OVERLAPPING"
    Incoherent -> "INCOHERENT"
    Overlaps -> "OVERLAPS"
    FieldOverlap -> "overlap"
    DefaultOverlap -> mempty

--------------------------------------------------------------------------------

-- | From 'prettyHiding'
--   @renderHiding info visible text@ puts the correct braces
--   around @text@ according to info @info@ and returns
--   @visible text@ if the we deal with a visible thing.
renderHiding :: (LensHiding a) => a -> (Inlines -> Inlines) -> Inlines -> Inlines
renderHiding a parensF =
  case getHiding a of
    Hidden -> braces'
    Instance {} -> dbraces
    NotHidden -> parensF

renderRelevance :: (LensRelevance a) => a -> Inlines -> Inlines
renderRelevance a d =
  if show d == "_" then d else render (getRelevance a) <> d

renderQuantity :: (LensQuantity a) => a -> Inlines -> Inlines
renderQuantity a d =
  if show d == "_" then d else render (getQuantity a) <+> d

instance Render Lock where
  render = \case
    IsLock LockOLock -> "@lock"
    IsLock LockOTick -> "@tick"
    IsNotLock -> mempty

renderErased :: Erased -> Inlines -> Inlines
renderErased = renderQuantity . asQuantity

renderCohesion :: (LensCohesion a) => a -> Inlines -> Inlines
renderCohesion a d =
  if show d == "_" then d else render (getCohesion a) <+> d

--------------------------------------------------------------------------------

instance (Render p, Render e) => Render (RewriteEqn' qn nm p e) where
  render = \case
    Rewrite es -> prefixedThings (text "rewrite") (render . snd <$> toList es)
    Invert _ pes -> prefixedThings (text "invert") (toList pes <&> (\(p, e) -> render p <+> "<-" <+> render e) . namedThing)
    LeftLet pes  -> prefixedThings (text "using") [render p <+> "<-" <+> render e | (p, e) <- List1.toList pes]

prefixedThings :: Inlines -> [Inlines] -> Inlines
prefixedThings kw = \case
  [] -> mempty
  (doc : docs) -> fsep $ (kw <+> doc) : fmap ("|" <+>) docs

instance Render Induction where
  render Inductive = "inductive"
  render CoInductive = "coinductive"