-- Should stay in sync with the import list of GHC.HsToCore.Quote

 templateHaskellNames = [

     mkNameName, mkNameG_vName, mkNameG_dName, mkNameG_tcName, mkNameG_fldName,

     mkNameLName,

     mkNameSName, mkNameQName,

 modNameTyConName       = thTc (fsLit "ModName")        modNameTyConKey

 quasiQuoterTyConName   = mk_known_key_name tcName qqLib (fsLit "QuasiQuoter") quasiQuoterTyConKey

     mkNameName, mkNameG_vName, mkNameG_fldName, mkNameG_dName, mkNameG_tcName,

     mkNameLName, mkNameSName, liftStringName, unTypeName, unTypeCodeName,

     unsafeCodeCoerceName, liftTypedName, mkModNameName, mkNameQName :: Name

 sequenceQName  = thMonadFun (fsLit "sequenceQ") sequenceQIdKey

 newNameName    = thMonadFun (fsLit "newName")   newNameIdKey

 mkNameName     = thFun (fsLit "mkName")     mkNameIdKey

 -- IdUniques available: 200-499

 -- If you want to change this, make sure you check in GHC.Builtin.Names

     mkNameIdKey, mkNameG_vIdKey, mkNameG_fldIdKey, mkNameG_dIdKey, mkNameG_tcIdKey,

     mkNameLIdKey, mkNameSIdKey, unTypeIdKey, unTypeCodeIdKey,

     unsafeCodeCoerceIdKey, liftTypedIdKey, mkModNameIdKey, mkNameQIdKey :: Unique

 sequenceQIdKey      = mkPreludeMiscIdUnique 202

 liftIdKey           = mkPreludeMiscIdUnique 203

 newNameIdKey         = mkPreludeMiscIdUnique 204

   [| \x -> x |]

 ====>

   [| \x -> $(f [| x |]) |]

 ====>

 -}

 import qualified GHC.Internal.Generics as Generics (Fixity(..))

 import GHC.Internal.Generics hiding (Fixity(..))

                              -- So we can give Data instance for U1, V1, ...

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

 --

 -- | @since base-4.12.0.0

 deriving instance Data a => Data (Down a)

 {-# OPTIONS_HADDOCK not-home #-} -- we want users to import Language.Haskell.TH.Syntax instead

 -- | This module is used internally in GHC's integration with Template Haskell

 -- and defines the abstract syntax of Template Haskell.

 #ifdef BOOTSTRAP_TH

 import Prelude

 import System.IO.Unsafe ( unsafePerformIO )

 import Data.Char        ( isAlpha, isAlphaNum, isUpper )

 import Data.List.NonEmpty ( NonEmpty(..) )

 import GHC.Generics     ( Generic )

 #else

 import GHC.Internal.Base hiding (NonEmpty(..),Type, Module, sequence)

 import GHC.Internal.Data.NonEmpty (NonEmpty(..))

 import GHC.Internal.Data.Traversable

 import GHC.Internal.Word

 -- | The name of a module.

 newtype ModName = ModName String        -- Module name

 -- | The name of a package.

 newtype PkgName = PkgName String        -- package name

 -- | Obtained from 'reifyModule' and 'Language.Haskell.TH.Lib.thisModule'.

 data Module = Module PkgName ModName -- package qualified module name

 -- | An "Occurence Name".

 newtype OccName = OccName String

 -- | Smart constructor for 'ModName'

 mkModName :: String -> ModName

 (such as @let x = ...@ or @\x -> ...@), but names constructed using

 @lookupValueName@, @lookupTypeName@, @'f@, @''T@ may not.

 -}

 instance Ord Name where

     -- check if unique is different before looking at strings

                 -- An original name (occurrences only, not binders)

                 -- Need the namespace too to be sure which

                 -- thing we are naming

 data NameSpace = VarName        -- ^ Variables

                | DataName       -- ^ Data constructors

                    --     of the datatype (regardless of whether this constructor has this field).

                    --   - For a field of a pattern synonym, this is the name of the pattern synonym.

                  }

 -- | @Uniq@ is used by GHC to distinguish names from each other.

 type Uniq = Integer

         , loc_module   :: String

         , loc_start    :: CharPos

         , loc_end      :: CharPos }

 type CharPos = (Int, Int)       -- ^ Line and character position

   | TyVarI      -- Scoped type variable

         Name

         Type    -- What it is bound to

 -- | Obtained from 'reifyModule' in the 'Q' Monad.

 data ModuleInfo =

   -- | Contains the import list of the module.

   ModuleInfo [Module]

 {- |

 In 'ClassOpI' and 'DataConI', name of the parent class or type

 -- | Fixity, as specified in a @infix[lr] n@ declaration.

 data Fixity          = Fixity Int FixityDirection

 -- | The associativity of an operator, as in an @infix@ declaration.

 data FixityDirection = InfixL | InfixR | InfixN

 -- | Highest allowed operator precedence for 'Fixity' constructor (answer: 9)

 maxPrecedence :: Int

          | StringPrimL [Word8]  -- ^ @"string"#@. A primitive C-style string, type 'Addr#'

          | BytesPrimL Bytes     -- ^ Some raw bytes, type 'Addr#':

          | CharPrimL Char       -- ^ @\'c\'#@

     -- We could add Int, Float, Double etc, as we do in HsLit,

     -- but that could complicate the

    -- , bytesInitialized :: Bool -- ^ False: only use `bytesSize` to allocate

    --                            --   an uninitialized region

    }

 -- We can't derive Show instance for Bytes because we don't want to show the

 -- pointer value but the actual bytes (similarly to what ByteString does). See

   | TypeP Type                      -- ^ @{ type p }@

   | InvisP Type                     -- ^ @{ @p }@

   | OrP (NonEmpty Pat)              -- ^ @{ p1; p2 }@

 -- | A (field name, pattern) pair. See 'RecP'.

 type FieldPat = (Name,Pat)

 -- | A @case@-alternative

 data Match = Match Pat Body [Dec] -- ^ @case e of { pat -> body where decs }@

 -- | A clause consists of patterns, guards, a body expression, and a list of

 -- declarations under a @where@. Clauses are seen in equations for function

 -- etc.

 data Clause = Clause [Pat] Body [Dec]

                                   -- ^ @f { p1 p2 = body where decs }@

 -- | A Haskell expression.

 data Exp

   | ForallE [TyVarBndr Specificity] Exp -- ^ @forall \<vars\>. \<expr\>@

   | ForallVisE [TyVarBndr ()] Exp      -- ^ @forall \<vars\> -> \<expr\>@

   | ConstrainedE [Exp] Exp             -- ^ @\<ctxt\> => \<expr\>@

 -- | A (field name, expression) pair. See 'RecConE' and 'RecUpdE'.

 type FieldExp = (Name,Exp)

                                  --      | e3 = e4 }

                                  -- where ds@

   | NormalB Exp              -- ^ @f p { = e } where ds@

 -- | A single guard.

 data Guard

   = NormalG Exp -- ^ @f x { | odd x } = x@

   | PatG [Stmt] -- ^ @f x { | Just y <- x, Just z <- y } = z@

 -- | A single statement, as in @do@-notation.

 data Stmt

   | NoBindS Exp   -- ^ @e@

   | ParS [[Stmt]] -- ^ @x <- e1 | s2, s3 | s4@ (in 'CompE')

   | RecS [Stmt]   -- ^ @rec { s1; s2 }@

 -- | A list/enum range expression.

 data Range = FromR Exp               -- ^ @[n ..]@

            | FromThenR Exp Exp       -- ^ @[n, m ..]@

            | FromToR Exp Exp         -- ^ @[n .. m]@

            | FromThenToR Exp Exp Exp -- ^ @[n, m .. k]@

 -- | A single declaration.

 data Dec

       --

       -- Implicit parameter binding declaration. Can only be used in let

       -- and where clauses which consist entirely of implicit bindings.

 -- | A way to specify a namespace to look in when GHC needs to find

 --   a name's source

                            --   or type variable

   | DataNamespaceSpecifier -- ^ Name should be a term-level entity, such as a

                            --   function, data constructor, or pattern synonym

 -- | Varieties of allowed instance overlap.

 data Overlap = Overlappable   -- ^ May be overlapped by more specific instances

              | Incoherent     -- ^ Both 'Overlapping' and 'Overlappable', and

                               -- pick an arbitrary one if multiple choices are

                               -- available.

 -- | A single @deriving@ clause at the end of a datatype declaration.

 data DerivClause = DerivClause (Maybe DerivStrategy) Cxt

     -- ^ @{ deriving stock (Eq, Ord) }@

 -- | What the user explicitly requests when deriving an instance with

 -- @-XDerivingStrategies@.

                    | AnyclassStrategy -- ^ @deriving {anyclass} C@, @-XDeriveAnyClass@

                    | NewtypeStrategy  -- ^ @deriving {newtype} C@, @-XGeneralizedNewtypeDeriving@

                    | ViaStrategy Type -- ^ @deriving C {via T}@, @-XDerivingVia@

 -- | A pattern synonym's type. Note that a pattern synonym's /fully/

 -- specified type has a peculiar shape coming with two forall

 -- between @type family@ and @where@.

 data TypeFamilyHead =

   TypeFamilyHead Name [TyVarBndr BndrVis] FamilyResultSig (Maybe InjectivityAnn)

 -- | One equation of a type family instance or closed type family. The

 -- arguments are the left-hand-side type and the right-hand-side result.

 --            ('VarT' a)

 -- @

 data TySynEqn = TySynEqn (Maybe [TyVarBndr ()]) Type Type

 -- | [Functional dependency](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/functional_dependencies.html)

 -- syntax, as in a class declaration.

 data FunDep = FunDep [Name] [Name] -- ^ @class C a b {| a -> b}@

 -- | A @foreign@ declaration.

 data Foreign = ImportF Callconv Safety String Name Type

              -- ^ @foreign import callconv safety "foreign_name" haskellName :: type@

              | ExportF Callconv        String Name Type

              -- ^ @foreign export callconv "foreign_name" haskellName :: type@

 -- keep Callconv in sync with module ForeignCall in ghc/compiler/GHC/Types/ForeignCall.hs

 -- | A calling convention identifier, as in a 'Foreign' declaration.

 data Callconv = CCall | StdCall | CApi | Prim | JavaScript

 -- | A safety level, as in a 'Foreign' declaration.

 data Safety = Unsafe | Safe | Interruptible

 data Pragma = InlineP         Name Inline RuleMatch Phases

             -- ^ @{ {\-\# [inline] [rule match] [phases] [phases] name #-} }@. See

                 -- ^ @{ {\-\# COMPLETE C_1, ..., C_i [ :: T ] \#-} }@

             | SCCP            Name (Maybe String)

                 -- ^ @{ {\-\# SCC fun "optional_name" \#-} }@

 -- | An inline pragma.

 data Inline = NoInline

             -- ^ @{ {\-\# INLINE ... #-} }@

             | Inlinable

             -- ^ @{ {\-\# INLINABLE ... #-} }@

 -- | A @CONLIKE@ modifier, as in one of the various inline pragmas, or lack

 -- thereof ('FunLike').

                -- ^ @{ {\-\# CONLIKE [inline] ... #-} }@

                | FunLike

                -- ^ @{ {\-\# [inline] ... #-} }@

 -- | Phase control syntax.

 data Phases = AllPhases

             -- ^ @[n]@

             | BeforePhase Int

             -- ^ @[~n]@

 -- | A binder found in the @forall@ of a @RULES@ pragma.

 data RuleBndr = RuleVar Name

               -- ^ @forall {a} ... .@

               | TypedRuleVar Name Type

               -- ^ @forall {(a :: t)} ... .@

 -- | The target of an @ANN@ pragma

 data AnnTarget = ModuleAnnotation

                -- ^ @{\-\# ANN type {name} ... #-}@

                | ValueAnnotation Name

                -- ^ @{\-\# ANN {name} ... #-}@

 -- | A context, as found on the left side of a @=>@ in a type.

 type Cxt = [Pred]                 -- ^ @(Eq a, Ord b)@

   = NoSourceUnpackedness -- ^ @C a@

   | SourceNoUnpack       -- ^ @C { {\-\# NOUNPACK \#-\} } a@

   | SourceUnpack         -- ^ @C { {\-\# UNPACK \#-\} } a@

 -- | 'SourceStrictness' corresponds to strictness annotations found in the source code.

 --

 data SourceStrictness = NoSourceStrictness    -- ^ @C a@

                       | SourceLazy            -- ^ @C {~}a@

                       | SourceStrict          -- ^ @C {!}a@

 -- | Unlike 'SourceStrictness' and 'SourceUnpackedness', 'DecidedStrictness'

 -- refers to the strictness annotations that the compiler chooses for a data constructor

 data DecidedStrictness = DecidedLazy -- ^ Field inferred to not have a bang.

                        | DecidedStrict -- ^ Field inferred to have a bang.

                        | DecidedUnpack -- ^ Field inferred to be unpacked.

 -- | A data constructor.

 --

              -- Invariant: the list must be non-empty.

              [VarBangType] -- ^ The constructor arguments

              Type -- ^ See Note [GADT return type]

 -- Note [GADT return type]

 -- ~~~~~~~~~~~~~~~~~~~~~~~

 -- | Strictness information in a data constructor's argument.

 data Bang = Bang SourceUnpackedness SourceStrictness

          -- ^ @C { {\-\# UNPACK \#-\} !}a@

 -- | A type with a strictness annotation, as in data constructors. See 'Con'.

 type BangType    = (Bang, Type)

   = Unidir             -- ^ @pattern P x {<-} p@

   | ImplBidir          -- ^ @pattern P x {=} p@

   | ExplBidir [Clause] -- ^ @pattern P x {<-} p where P x = e@

 -- | A pattern synonym's argument type.

 data PatSynArgs

   = PrefixPatSyn [Name]        -- ^ @pattern P {x y z} = p@

   | InfixPatSyn Name Name      -- ^ @pattern {x P y} = p@

   | RecordPatSyn [Name]        -- ^ @pattern P { {x,y,z} } = p@

 -- | A Haskell type.

 data Type = ForallT [TyVarBndr Specificity] Cxt Type -- ^ @forall \<vars\>. \<ctxt\> => \<type\>@

           | LitT TyLit                     -- ^ @0@, @1@, @2@, etc.

           | WildCardT                      -- ^ @_@

           | ImplicitParamT String Type     -- ^ @?x :: t@

 -- | The specificity of a type variable in a @forall ...@.

 data Specificity = SpecifiedSpec          -- ^ @a@

                  | InferredSpec           -- ^ @{a}@

 -- | The @flag@ type parameter is instantiated to one of the following types:

 --

 --

 data TyVarBndr flag = PlainTV  Name flag      -- ^ @a@

                     | KindedTV Name flag Kind -- ^ @(a :: k)@

 -- | Visibility of a type variable. See [Inferred vs. specified type variables](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/type_applications.html#inferred-vs-specified-type-variables).

 data BndrVis = BndrReq                    -- ^ @a@

              | BndrInvis                  -- ^ @\@a@

 -- | Type family result signature

 data FamilyResultSig = NoSig              -- ^ no signature

                      | KindSig  Kind      -- ^ @k@

                      | TyVarSig (TyVarBndr ()) -- ^ @= r, = (r :: k)@

 -- | Injectivity annotation as in an [injective type family](https://ghc.gitlab.haskell.org/ghc/doc/users_guide/exts/type_families.html)

 data InjectivityAnn = InjectivityAnn Name [Name]

 -- | Type-level literals.

 data TyLit = NumTyLit Integer             -- ^ @2@

            | StrTyLit String              -- ^ @\"Hello\"@

            | CharTyLit Char               -- ^ @\'C\'@, @since 4.16.0.0

 -- | Role annotations

 data Role = NominalR            -- ^ @nominal@

           | RepresentationalR   -- ^ @representational@

           | PhantomR            -- ^ @phantom@

           | InferR              -- ^ @_@

 -- | Annotation target for reifyAnnotations

 data AnnLookup = AnnLookupModule Module

                | AnnLookupName Name

 -- | To avoid duplication between kinds and types, they

 -- are defined to be the same. Naturally, you would never

   | ArgDoc Name Int   -- ^ At a specific argument of a function, indexed by its

                       -- position.

   | InstDoc Type      -- ^ At a class or family instance.

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

 --              Internal helper functions