Skip to content

A peer-to-peer stack for code collaboration

2.9 KB
Raw Blame
{-# LANGUAGE UndecidableInstances #-}

module Radicle.Lang.Annotation where

import           Codec.Serialise (Serialise)
import           Data.Copointed (Copointed(..))
import qualified Data.Text as T
import           GHC.Stack
import           Protolude hiding (SrcLoc)
import qualified Text.Megaparsec.Pos as Par

import           Radicle.Lang.Internal.Orphans ()

newtype Annotated t f = Annotated (t (f (Annotated t f)))
    deriving (Generic)

-- Really should depend on Eq1 etc. but that is so much boilerplate.
-- Instead we use some UndecidableInstances.
deriving instance (Eq (t (f (Annotated t f)))) => Eq (Annotated t f)
deriving instance (Ord (t (f (Annotated t f)))) => Ord (Annotated t f)
deriving instance (Read (t (f (Annotated t f)))) => Read (Annotated t f)
deriving instance (Show (t (f (Annotated t f)))) => Show (Annotated t f)
deriving instance (Serialise (t (f (Annotated t f)))) => Serialise (Annotated t f)

class Annotation t where
    -- We use the call stack to create source location annotations for interpreter-created objects
    toAnnotation :: HasCallStack => a -> t a

instance Annotation Identity where
    toAnnotation = Identity

untag :: (Functor f, Copointed t) => Annotated t f -> Annotated Identity f
untag (Annotated t) = Annotated . Identity $ untag <$> copoint t

tagDefault :: (Functor f, Annotation t) => Annotated Identity f -> Annotated t f
tagDefault (Annotated (Identity t)) = Annotated (toAnnotation (tagDefault <$> t))

match :: (Copointed t) => Annotated t f -> f (Annotated t f)
match (Annotated t) = copoint t

annotate :: (HasCallStack, Annotation t) => f (Annotated t f) -> Annotated t f
annotate = withFrozenCallStack (Annotated . toAnnotation)


data SrcPos = SrcPos Par.SourcePos
            -- | If not associated with a source position, record where
            -- in the interpreter this node was created (if only to know
            -- what we need to improve).
            --
            -- We use Text instead of CallStack because CallStack has no
            -- Read instance, and it's not worth it to make a parser.
            | InternalPos Text
    deriving (Eq, Ord, Read, Show, Generic)

instance Serialise SrcPos

thisPos :: HasCallStack => SrcPos
thisPos = InternalPos $ T.intercalate "\n" (map prettyCallSite $ getCallStack callStack)
  where
    prettyCallSite (f, SrcLoc{..}) =
        toS $ srcLocFile <> ":" <> show srcLocStartLine <> ":" <> show srcLocStartCol <> " " <> f

data WithPos a = WithPos SrcPos a
    deriving (Read, Show, Generic, Functor, Foldable, Traversable)

instance Serialise a => Serialise (WithPos a)

-- Ignore source locations when comparing.
instance Eq a => Eq (WithPos a) where
    WithPos _ x == WithPos _ y = x == y

instance (Ord a) => Ord (WithPos a) where
    compare (WithPos _ x) (WithPos _ y) = compare x y

instance Copointed WithPos where
    copoint (WithPos _ x) = x

instance Annotation WithPos where
    toAnnotation = WithPos thisPos