{-# LANGUAGE RecordWildCards #-}

module HIndent.Ast.Name.Infix
  ( InfixName
  , mkInfixName
  ) where

import Data.Maybe
import qualified GHC.Types.Name as GHC
import qualified GHC.Types.Name.Reader as GHC
import qualified GHC.Unit.Module as GHC
import HIndent.Ast.NodeComments
import {-# SOURCE #-} HIndent.Pretty
import HIndent.Pretty.Combinators
import HIndent.Pretty.NodeComments

data InfixName = InfixName
  { InfixName -> OccName
name :: GHC.OccName
  , InfixName -> Maybe ModuleName
moduleName :: Maybe GHC.ModuleName
  , InfixName -> Bool
backtick :: Bool
  }

instance CommentExtraction InfixName where
  nodeComments :: InfixName -> NodeComments
nodeComments InfixName {} = [LEpaComment] -> [LEpaComment] -> [LEpaComment] -> NodeComments
NodeComments [] [] []

instance Pretty InfixName where
  pretty' :: InfixName -> Printer ()
pretty' InfixName {Bool
Maybe ModuleName
OccName
name :: InfixName -> OccName
moduleName :: InfixName -> Maybe ModuleName
backtick :: InfixName -> Bool
name :: OccName
moduleName :: Maybe ModuleName
backtick :: Bool
..} =
    Printer () -> Printer ()
forall {a}. Printer a -> Printer a
wrap (Printer () -> Printer ()) -> Printer () -> Printer ()
forall a b. (a -> b) -> a -> b
$ [Printer ()] -> Printer ()
hDotSep ([Printer ()] -> Printer ()) -> [Printer ()] -> Printer ()
forall a b. (a -> b) -> a -> b
$ [Maybe (Printer ())] -> [Printer ()]
forall a. [Maybe a] -> [a]
catMaybes [ModuleName -> Printer ()
forall a. Pretty a => a -> Printer ()
pretty (ModuleName -> Printer ())
-> Maybe ModuleName -> Maybe (Printer ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModuleName
moduleName, Printer () -> Maybe (Printer ())
forall a. a -> Maybe a
Just (Printer () -> Maybe (Printer ()))
-> Printer () -> Maybe (Printer ())
forall a b. (a -> b) -> a -> b
$ OccName -> Printer ()
forall a. Pretty a => a -> Printer ()
pretty OccName
name]
    where
      wrap :: Printer a -> Printer a
wrap =
        if Bool
backtick
          then Printer a -> Printer a
forall {a}. Printer a -> Printer a
backticks
          else Printer a -> Printer a
forall a. a -> a
id

mkInfixName :: GHC.RdrName -> InfixName
mkInfixName :: RdrName -> InfixName
mkInfixName (GHC.Unqual OccName
name) = OccName -> Maybe ModuleName -> Bool -> InfixName
InfixName OccName
name Maybe ModuleName
forall a. Maybe a
Nothing (OccName -> Bool
backticksNeeded OccName
name)
mkInfixName (GHC.Qual ModuleName
modName OccName
name) =
  OccName -> Maybe ModuleName -> Bool -> InfixName
InfixName OccName
name (ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
modName) (OccName -> Bool
backticksNeeded OccName
name)
mkInfixName (GHC.Orig {}) =
  [Char] -> InfixName
forall a. HasCallStack => [Char] -> a
error [Char]
"This AST node should not appear in the parser output."
mkInfixName (GHC.Exact Name
name) =
  OccName -> Maybe ModuleName -> Bool -> InfixName
InfixName (Name -> OccName
forall name. HasOccName name => name -> OccName
GHC.occName Name
name) Maybe ModuleName
forall a. Maybe a
Nothing (OccName -> Bool
backticksNeeded (OccName -> Bool) -> OccName -> Bool
forall a b. (a -> b) -> a -> b
$ Name -> OccName
forall name. HasOccName name => name -> OccName
GHC.occName Name
name)

backticksNeeded :: GHC.OccName -> Bool
backticksNeeded :: OccName -> Bool
backticksNeeded = Bool -> Bool
not (Bool -> Bool) -> (OccName -> Bool) -> OccName -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OccName -> Bool
GHC.isSymOcc