{-# LANGUAGE CPP                  #-}
{-# LANGUAGE DataKinds            #-}
{-# LANGUAGE FlexibleContexts     #-}
{-# LANGUAGE LambdaCase           #-}
{-# LANGUAGE RecordWildCards      #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE ViewPatterns         #-}

{-# OPTIONS_GHC -Wno-orphans #-}

-- | Thin layer around ghc-tcplugin-api
module Data.Record.Anon.Internal.Plugin.TC.GhcTcPluginAPI (
    -- * Standard exports
    module GHC.TcPlugin.API
  , module GHC.Builtin.Names
  , module GHC.Builtin.Types
  , module GHC.Builtin.Types.Prim
  , module GHC.Core.Make
  , module GHC.Utils.Outputable

    -- * New functonality
  , isCanonicalVarEq
  ) where

#if __GLASGOW_HASKELL__ < 900
import Data.List.NonEmpty (NonEmpty, toList)
#endif

import GHC.TcPlugin.API
import GHC.Builtin.Names
import GHC.Builtin.Types
import GHC.Builtin.Types.Prim
import GHC.Core.Make
import GHC.Utils.Outputable

#if __GLASGOW_HASKELL__ >= 808 &&  __GLASGOW_HASKELL__ < 810
import TcRnTypes (Ct(..))
#endif

#if __GLASGOW_HASKELL__ >= 810 &&  __GLASGOW_HASKELL__ < 900
import Constraint (Ct(..))
#endif

#if __GLASGOW_HASKELL__ >= 900 &&  __GLASGOW_HASKELL__ < 902
import GHC.Tc.Types.Constraint (Ct(..))
#endif

#if __GLASGOW_HASKELL__ >= 902
import GHC.Tc.Types.Constraint (Ct(..), CanEqLHS(..))
#endif

isCanonicalVarEq :: Ct -> Maybe (TcTyVar, Type)
#if __GLASGOW_HASKELL__ >= 808 &&  __GLASGOW_HASKELL__ < 902
isCanonicalVarEq :: Ct -> Maybe (TcTyVar, Type)
isCanonicalVarEq = \case
    CTyEqCan{CtEvidence
EqRel
Type
TcTyVar
cc_ev :: Ct -> CtEvidence
cc_tyvar :: Ct -> TcTyVar
cc_rhs :: Ct -> Type
cc_eq_rel :: Ct -> EqRel
cc_eq_rel :: EqRel
cc_rhs :: Type
cc_tyvar :: TcTyVar
cc_ev :: CtEvidence
..}  -> (TcTyVar, Type) -> Maybe (TcTyVar, Type)
forall a. a -> Maybe a
Just (TcTyVar
cc_tyvar, Type
cc_rhs)
    CFunEqCan{[Type]
CtEvidence
TcTyVar
TyCon
cc_tyargs :: Ct -> [Type]
cc_fun :: Ct -> TyCon
cc_fsk :: Ct -> TcTyVar
cc_fsk :: TcTyVar
cc_tyargs :: [Type]
cc_fun :: TyCon
cc_ev :: CtEvidence
cc_ev :: Ct -> CtEvidence
..} -> (TcTyVar, Type) -> Maybe (TcTyVar, Type)
forall a. a -> Maybe a
Just (TcTyVar
cc_fsk, TyCon -> [Type] -> Type
mkTyConApp TyCon
cc_fun [Type]
cc_tyargs)
    Ct
_otherwise    -> Maybe (TcTyVar, Type)
forall a. Maybe a
Nothing
#endif
#if __GLASGOW_HASKELL__ >= 902
isCanonicalVarEq = \case
    CEqCan{..}
      | TyVarLHS var <- cc_lhs
      -> Just (var, cc_rhs)
      | TyFamLHS tyCon args <- cc_lhs
      , Just var            <- getTyVar_maybe cc_rhs
      -> Just (var, mkTyConApp tyCon args)
    _otherwise
      -> Nothing
#endif

-- TODO: Ideally we would actually show the location information obviously
instance Outputable CtLoc where
  ppr :: CtLoc -> SDoc
ppr CtLoc
_ = String -> SDoc
text String
"<CtLoc>"

#if __GLASGOW_HASKELL__ < 900
instance Outputable a => Outputable (NonEmpty a) where
  ppr :: NonEmpty a -> SDoc
ppr = [a] -> SDoc
forall a. Outputable a => a -> SDoc
ppr ([a] -> SDoc) -> (NonEmpty a -> [a]) -> NonEmpty a -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty a -> [a]
forall a. NonEmpty a -> [a]
toList
#endif

#if __GLASGOW_HASKELL__ >= 902
instance (Outputable l, Outputable e) => Outputable (GenLocated l e) where
  ppr (L l e) = parens $ text "L" <+> ppr l <+> ppr e
#endif