{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards   #-}

module Data.Record.Internal.Plugin.Names (
    -- * Qualified names
    QualifiedNames(..)
  , getQualifiedNames
    -- * Unqualified names
  , UnqualifiedNames(..)
  , getUnqualifiedNames
  ) where

import Data.Record.Internal.GHC.Shim

{-------------------------------------------------------------------------------
  Qualified names
-------------------------------------------------------------------------------}

data QualifiedNames = QualifiedNames {

      --
      -- Base
      --

      QualifiedNames -> LRdrName
type_Constraint  :: LRdrName
    , QualifiedNames -> LRdrName
type_GHC_Generic :: LRdrName
    , QualifiedNames -> LRdrName
type_GHC_Rep     :: LRdrName
    , QualifiedNames -> LRdrName
type_Proxy       :: LRdrName
    , QualifiedNames -> LRdrName
type_Type        :: LRdrName
    , QualifiedNames -> LRdrName
proxy            :: LRdrName
    , QualifiedNames -> LRdrName
ghc_from         :: LRdrName
    , QualifiedNames -> LRdrName
ghc_to           :: LRdrName

      --
      -- AnyArray
      --

    , QualifiedNames -> LRdrName
type_AnyArray    :: LRdrName
    , QualifiedNames -> LRdrName
anyArrayFromList :: LRdrName
    , QualifiedNames -> LRdrName
anyArrayToList   :: LRdrName
    , QualifiedNames -> LRdrName
anyArrayIndex    :: LRdrName
    , QualifiedNames -> LRdrName
anyArrayUpdate   :: LRdrName

      --
      -- large-generics
      --

    , QualifiedNames -> LRdrName
type_LR_Generic     :: LRdrName
    , QualifiedNames -> LRdrName
type_LR_MetadataOf  :: LRdrName
    , QualifiedNames -> LRdrName
type_LR_Constraints :: LRdrName
    , QualifiedNames -> LRdrName
lr_from             :: LRdrName
    , QualifiedNames -> LRdrName
lr_to               :: LRdrName
    , QualifiedNames -> LRdrName
lr_dict             :: LRdrName
    , QualifiedNames -> LRdrName
lr_metadata         :: LRdrName

      -- .. wrappers

    , QualifiedNames -> LRdrName
type_Rep         :: LRdrName
    , QualifiedNames -> LRdrName
type_Dict        :: LRdrName
    , QualifiedNames -> LRdrName
gcompare         :: LRdrName
    , QualifiedNames -> LRdrName
geq              :: LRdrName
    , QualifiedNames -> LRdrName
gshowsPrec       :: LRdrName
    , QualifiedNames -> LRdrName
noInlineUnsafeCo :: LRdrName

      -- .. utilities

    , QualifiedNames -> LRdrName
anyArrayToRep   :: LRdrName
    , QualifiedNames -> LRdrName
anyArrayFromRep :: LRdrName
    , QualifiedNames -> LRdrName
mkDicts         :: LRdrName
    , QualifiedNames -> LRdrName
mkDict          :: LRdrName
    , QualifiedNames -> LRdrName
mkStrictField   :: LRdrName
    , QualifiedNames -> LRdrName
mkLazyField     :: LRdrName
    , QualifiedNames -> LRdrName
mkMetadata      :: LRdrName

      -- .. ThroughLRGenerics

    , QualifiedNames -> LRdrName
type_ThroughLRGenerics  :: LRdrName
    , QualifiedNames -> LRdrName
wrapThroughLRGenerics   :: LRdrName
    , QualifiedNames -> LRdrName
unwrapThroughLRGenerics :: LRdrName

      --
      -- record-hasfield
      --

    , QualifiedNames -> LRdrName
type_HasField :: LRdrName
    , QualifiedNames -> LRdrName
hasField      :: LRdrName
    }

-- | Resolve qualified names
--
-- We try to import whenever possible from "Data.Record.Plugin.Runtime"; only
-- when this is /really/ not possible do we import from other modules. We do
-- this to avoid two problems:
--
-- * When we resolve a name, we must specify the module where something is
--   /defined/, not merely a module that /exports/ the thing we need; this means
--   that this is quite brittle.
--
-- * When we resolve a name from a different package, users must explicitly
--   define a dependency on that other package.
getQualifiedNames :: Hsc QualifiedNames
getQualifiedNames :: Hsc QualifiedNames
getQualifiedNames = do
    --
    -- base
    --

    LRdrName
type_Constraint  <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
runtime     forall a. Maybe a
Nothing String
"Constraint"
    LRdrName
type_GHC_Generic <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
ghcGenerics forall a. Maybe a
Nothing String
"Generic"
    LRdrName
type_GHC_Rep     <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
ghcGenerics forall a. Maybe a
Nothing String
"Rep"
    LRdrName
type_Proxy       <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
runtime     forall a. Maybe a
Nothing String
"Proxy"
    LRdrName
type_Type        <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
runtime     forall a. Maybe a
Nothing String
"Type"
    LRdrName
proxy            <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime     forall a. Maybe a
Nothing String
"proxy"
    LRdrName
ghc_from         <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
ghcGenerics forall a. Maybe a
Nothing String
"from"
    LRdrName
ghc_to           <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
ghcGenerics forall a. Maybe a
Nothing String
"to"

    --
    -- AnyArray
    --

    LRdrName
type_AnyArray    <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
runtime forall a. Maybe a
Nothing String
"AnyArray"
    LRdrName
anyArrayFromList <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"anyArrayFromList"
    LRdrName
anyArrayToList   <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"anyArrayToList"
    LRdrName
anyArrayIndex    <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"anyArrayIndex"
    LRdrName
anyArrayUpdate   <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"anyArrayUpdate"

    --
    -- large-generics
    --

    LRdrName
type_LR_Generic     <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
largeGenerics (forall a. a -> Maybe a
Just FastString
"large-generics") String
"Generic"
    LRdrName
type_LR_Constraints <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
largeGenerics (forall a. a -> Maybe a
Just FastString
"large-generics") String
"Constraints"
    LRdrName
type_LR_MetadataOf  <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
largeGenerics (forall a. a -> Maybe a
Just FastString
"large-generics") String
"MetadataOf"
    LRdrName
lr_from             <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
largeGenerics (forall a. a -> Maybe a
Just FastString
"large-generics") String
"from"
    LRdrName
lr_to               <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
largeGenerics (forall a. a -> Maybe a
Just FastString
"large-generics") String
"to"
    LRdrName
lr_dict             <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
largeGenerics (forall a. a -> Maybe a
Just FastString
"large-generics") String
"dict"
    LRdrName
lr_metadata         <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
largeGenerics (forall a. a -> Maybe a
Just FastString
"large-generics") String
"metadata"

    -- .. utilities

    LRdrName
anyArrayToRep   <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"anyArrayToRep"
    LRdrName
anyArrayFromRep <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"anyArrayFromRep"
    LRdrName
mkDicts         <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"mkDicts"
    LRdrName
mkDict          <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"mkDict"
    LRdrName
mkStrictField   <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"mkStrictField"
    LRdrName
mkLazyField     <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"mkLazyField"
    LRdrName
mkMetadata      <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"mkMetadata"

    -- .. wrappers

    LRdrName
type_Rep         <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
runtime forall a. Maybe a
Nothing String
"Rep"
    LRdrName
type_Dict        <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
runtime forall a. Maybe a
Nothing String
"Dict"
    LRdrName
gcompare         <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"gcompare"
    LRdrName
geq              <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"geq"
    LRdrName
gshowsPrec       <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"gshowsPrec"
    LRdrName
noInlineUnsafeCo <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"noInlineUnsafeCo"

    -- .. ThroughLRGenerics

    LRdrName
type_ThroughLRGenerics  <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
runtime forall a. Maybe a
Nothing String
"ThroughLRGenerics"
    LRdrName
wrapThroughLRGenerics   <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"wrapThroughLRGenerics"
    LRdrName
unwrapThroughLRGenerics <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
runtime forall a. Maybe a
Nothing String
"unwrapThroughLRGenerics"

    --
    -- record-hasfield
    --

    LRdrName
type_HasField <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupTcName  ModuleName
recordHasField (forall a. a -> Maybe a
Just FastString
"record-hasfield") String
"HasField"
    LRdrName
hasField      <- Name -> LRdrName
exact forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
<$> HasCallStack =>
ModuleName -> Maybe FastString -> String -> Hsc Name
lookupVarName ModuleName
recordHasField (forall a. a -> Maybe a
Just FastString
"record-hasfield") String
"hasField"

    forall (m :: Type -> Type) a. Monad m => a -> m a
return QualifiedNames{LRdrName
hasField :: LRdrName
type_HasField :: LRdrName
unwrapThroughLRGenerics :: LRdrName
wrapThroughLRGenerics :: LRdrName
type_ThroughLRGenerics :: LRdrName
noInlineUnsafeCo :: LRdrName
gshowsPrec :: LRdrName
geq :: LRdrName
gcompare :: LRdrName
type_Dict :: LRdrName
type_Rep :: LRdrName
mkMetadata :: LRdrName
mkLazyField :: LRdrName
mkStrictField :: LRdrName
mkDict :: LRdrName
mkDicts :: LRdrName
anyArrayFromRep :: LRdrName
anyArrayToRep :: LRdrName
lr_metadata :: LRdrName
lr_dict :: LRdrName
lr_to :: LRdrName
lr_from :: LRdrName
type_LR_MetadataOf :: LRdrName
type_LR_Constraints :: LRdrName
type_LR_Generic :: LRdrName
anyArrayUpdate :: LRdrName
anyArrayIndex :: LRdrName
anyArrayToList :: LRdrName
anyArrayFromList :: LRdrName
type_AnyArray :: LRdrName
ghc_to :: LRdrName
ghc_from :: LRdrName
proxy :: LRdrName
type_Type :: LRdrName
type_Proxy :: LRdrName
type_GHC_Rep :: LRdrName
type_GHC_Generic :: LRdrName
type_Constraint :: LRdrName
hasField :: LRdrName
type_HasField :: LRdrName
unwrapThroughLRGenerics :: LRdrName
wrapThroughLRGenerics :: LRdrName
type_ThroughLRGenerics :: LRdrName
mkMetadata :: LRdrName
mkLazyField :: LRdrName
mkStrictField :: LRdrName
mkDict :: LRdrName
mkDicts :: LRdrName
anyArrayFromRep :: LRdrName
anyArrayToRep :: LRdrName
noInlineUnsafeCo :: LRdrName
gshowsPrec :: LRdrName
geq :: LRdrName
gcompare :: LRdrName
type_Dict :: LRdrName
type_Rep :: LRdrName
lr_metadata :: LRdrName
lr_dict :: LRdrName
lr_to :: LRdrName
lr_from :: LRdrName
type_LR_Constraints :: LRdrName
type_LR_MetadataOf :: LRdrName
type_LR_Generic :: LRdrName
anyArrayUpdate :: LRdrName
anyArrayIndex :: LRdrName
anyArrayToList :: LRdrName
anyArrayFromList :: LRdrName
type_AnyArray :: LRdrName
ghc_to :: LRdrName
ghc_from :: LRdrName
proxy :: LRdrName
type_Type :: LRdrName
type_Proxy :: LRdrName
type_GHC_Rep :: LRdrName
type_GHC_Generic :: LRdrName
type_Constraint :: LRdrName
..}

  where
   exact :: Name -> LRdrName
   exact :: Name -> LRdrName
exact = forall e. e -> Located e
noLoc forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> RdrName
Exact

   runtime, recordHasField, ghcGenerics, largeGenerics :: ModuleName
   runtime :: ModuleName
runtime        = String -> ModuleName
mkModuleName String
"Data.Record.Plugin.Runtime"
   recordHasField :: ModuleName
recordHasField = String -> ModuleName
mkModuleName String
"GHC.Records.Compat"
   ghcGenerics :: ModuleName
ghcGenerics    = String -> ModuleName
mkModuleName String
"GHC.Generics"
   largeGenerics :: ModuleName
largeGenerics  = String -> ModuleName
mkModuleName String
"Data.Record.Generic"

{-------------------------------------------------------------------------------
  We use Prelude names unqualified.
-------------------------------------------------------------------------------}

data UnqualifiedNames = UnqualifiedNames {
      UnqualifiedNames -> LRdrName
unq_type_Eq   :: LRdrName
    , UnqualifiedNames -> LRdrName
unq_type_Int  :: LRdrName
    , UnqualifiedNames -> LRdrName
unq_type_Ord  :: LRdrName
    , UnqualifiedNames -> LRdrName
unq_type_Show :: LRdrName
    , UnqualifiedNames -> LRdrName
unq_compare   :: LRdrName
    , UnqualifiedNames -> LRdrName
unq_eq        :: LRdrName
    , UnqualifiedNames -> LRdrName
unq_error     :: LRdrName
    , UnqualifiedNames -> LRdrName
unq_showsPrec :: LRdrName
    }

getUnqualifiedNames :: UnqualifiedNames
getUnqualifiedNames :: UnqualifiedNames
getUnqualifiedNames = UnqualifiedNames {
      unq_type_Eq :: LRdrName
unq_type_Eq   = String -> LRdrName
tc String
"Eq"
    , unq_type_Int :: LRdrName
unq_type_Int  = String -> LRdrName
tc String
"Int"
    , unq_type_Ord :: LRdrName
unq_type_Ord  = String -> LRdrName
tc String
"Ord"
    , unq_type_Show :: LRdrName
unq_type_Show = String -> LRdrName
tc String
"Show"
    , unq_compare :: LRdrName
unq_compare   = String -> LRdrName
var String
"compare"
    , unq_eq :: LRdrName
unq_eq        = String -> LRdrName
var String
"=="
    , unq_error :: LRdrName
unq_error     = String -> LRdrName
var String
"error"
    , unq_showsPrec :: LRdrName
unq_showsPrec = String -> LRdrName
var String
"showsPrec"
    }
  where
    var, tc :: String -> LRdrName
    var :: String -> LRdrName
var String
x = forall e. e -> Located e
noLoc forall a b. (a -> b) -> a -> b
$ OccName -> RdrName
mkRdrUnqual forall a b. (a -> b) -> a -> b
$ String -> OccName
mkVarOcc String
x
    tc :: String -> LRdrName
tc  String
x = forall e. e -> Located e
noLoc forall a b. (a -> b) -> a -> b
$ OccName -> RdrName
mkRdrUnqual forall a b. (a -> b) -> a -> b
$ String -> OccName
mkTcOcc  String
x