fromStringName,

         -- Interpolated strings

         -- Enum stuff

         enumFromName, enumFromThenName,

 negateName        = varQual gHC_INTERNAL_NUM (fsLit "negate")      negateClassOpKey

 -- Module GHC.Internal.Data.String.Interpolate

 interpolateName = varQual gHC_INTERNAL_DATA_STRING_INTERPOLATE (fsLit "interpolate") interpolateKey

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

 proxyHashKey = mkPreludeMiscIdUnique 502

 -- String interpolation

 interpolateKey = mkPreludeMiscIdUnique 576

 ---------------- Template Haskell -------------------

   LangExt.ListTuplePuns -> "ListTuplePuns"

   LangExt.MultilineStrings -> "MultilineStrings"

   LangExt.StringInterpolation -> "StringInterpolation"

   LangExt.ExplicitLevelImports -> "ExplicitLevelImports"

   LangExt.ImplicitStagePersistence -> "ImplicitStagePersistence"

 ppr_expr (HsLit _ lit)       = ppr lit

 ppr_expr (HsOverLit _ lit)   = ppr lit

   where

     pprInterPart = \case

       HsInterStringRaw st s ->

           (HsStringTypeMulti, NoSourceText) -> pprHsStringMulti' (unpackFS s)

       HsInterStringExpr _ expr -> text "${" <> ppr_lexpr expr <> text "}"

     delim =

       case strType of

         HsStringTypeSingle -> char '"'

 hsExprType (HsIPVar v _) = dataConCantHappen v

 hsExprType (HsOverLit _ lit) = overLitType lit

 hsExprType (HsLit _ lit) = hsLitType lit

 hsExprType (HsLam _ _ (MG { mg_ext = match_group })) = matchGroupTcType match_group

 hsExprType (HsApp _ f _) = funResultTy $ lhsExprType f

 hsExprType (HsAppType x f _) = piResultTy (lhsExprType f) x

 dsExpr (OpApp x _ _ _)    = dataConCantHappen x

 dsExpr (SectionL x _ _)   = dataConCantHappen x

 dsExpr (SectionR x _ _)   = dataConCantHappen x

 {- *********************************************************************

         -- HsOverlit can definitely occur

 repE (HsOverLit _ l) = do { a <- repOverloadedLiteral l; repLit a }

 repE (HsLit _ l)     = do { a <- repLiteral l;           repLit a }

   parts' <- forM parts $ \case

     HsInterStringRaw _ s -> repInterStringRaw =<< coreStringLit s

     HsInterStringExpr _ e -> repInterStringExp =<< repLE e

 repE (HsLam _ LamSingle (MG { mg_alts = L _ [m] })) = repLambda m

 repE e@(HsLam _ LamSingle (MG { mg_alts = L _ _ })) = pprPanic "repE: HsLam with multiple alternatives" (ppr e)

 repE (HsLam _ LamCase (MG { mg_alts = L _ ms }))

 repDoBlock :: Name -> Maybe ModuleName -> Core [(M TH.Stmt)] -> MetaM (Core (M TH.Exp))

 repDoBlock doName maybeModName (MkC ss) = do

 repComp :: Core [(M TH.Stmt)] -> MetaM (Core (M TH.Exp))

 repComp (MkC ss) = rep2 compEName [ss]

 repClause (MkC ps) (MkC bod) (MkC ds) = rep2 clauseName [ps, bod, ds]

 -------------- Interpolated strings -----------------------------

 repInterStringRaw :: Core String -> MetaM (Core (M TH.InterStringPart))

 repInterStringRaw (MkC s) = rep2 interStringRawName [s]

 addTickHsExpr e@(HsOverLit {})          = return e

 addTickHsExpr e@(HsOverLabel{})         = return e

 addTickHsExpr e@(HsLit {})              = return e

   parts' <- forM parts $ \case

     part@(HsInterStringRaw {}) -> return part

     HsInterStringExpr x e -> HsInterStringExpr x <$> addTickLHsExpr e

 addTickHsExpr e@(HsEmbTy {})            = return e

 addTickHsExpr e@(HsHole {})             = return e

 addTickHsExpr e@(HsQual {})             = return e

         [ toHie (L mspan o)

         ]

       HsLit _ _ -> []

         [ toHie expr

         | HsInterStringExpr _ expr <- parts

         ]

  CHAR           { L _ (ITchar   _ _) }

  STRING         { L _ (ITstring _ StringTypeSingle _) }

  STRING_MULTI   { L _ (ITstring _ StringTypeMulti _) }

  STRING_INTER_END         { L _ (ITstringInterEnd   StringTypeSingle) }

  STRING_INTER_MULTI_END   { L _ (ITstringInterEnd   StringTypeMulti) }

  STRING_INTER_RAW         { L _ (ITstringInterRaw _ _) }

  STRING_INTER_EXP_OPEN    { L _ ITstringInterExpOpen }

 processStringInter strType tokBegin parts tokEnd = do

   parts' <- mapM mkInterStringPartPV $ processRawLexedStrings parts

   ams1 (L (comb2 tokBegin tokEnd) ()) $

   where

     processRawLexedStrings ::

       [Either (SourceText, RawLexedString) ECP] ->

       Left (src, s) -> pure $ HsInterStringRaw src (fsLit s)

       Right (ECP e) -> HsInterStringExpr noExtField <$> runPV e

 -- Utilities for combining source spans

 comb2 :: (HasLoc a, HasLoc b) => a -> b -> SrcSpan

 comb2 !a !b = combineHasLocs a b

 -- See Note [Parsing interpolated strings] and Note [Lexing interpolated strings]

 <0,string_inter> {

   s \" / { ifExtension StringInterpolationBit } { string_inter_begin }

   -- TODO(bchinn): interpolated multiline strings

 }

   | ITstring SourceText StringType FastString -- Note [Literal source text] in "GHC.Types.SourceText"

   -- See Note [Parsing interpolated strings]

   | ITstringInterRaw      SourceText RawLexedString -- Note [Literal source text] in "GHC.Types.SourceText"

   | ITstringInterExpOpen

   | ITstringInterExpClose

     endsInHash = currentChar (offsetBytes (len - 1) buf) == '#'

 string_inter_begin :: Action

   pushLexState string_inter_content

 string_inter_content_action :: Action

 string_inter_content_action span_init buf_init _ _ = go $ AI (psSpanStart span_init) buf_init

   | RequiredTypeArgumentsBit

   | MultilineStringsBit

   | StringInterpolationBit

   | LevelImportsBit

   -- Flags that are updated once parsing starts

       .|. RequiredTypeArgumentsBit    `xoptBit` LangExt.RequiredTypeArguments

       .|. MultilineStringsBit         `xoptBit` LangExt.MultilineStrings

       .|. StringInterpolationBit      `xoptBit` LangExt.StringInterpolation

       .|. LevelImportsBit             `xoptBit` LangExt.ExplicitLevelImports

     optBits =

           HaddockBit        `setBitIf` isHaddock

   and outputs the following tokens:

     , ITstringInterRaw      src "Hello "

     , ITqvarid                  ("Text.toUpper", "name")

     , ITvarid                   "name"

     , ITstringInterRaw      src "!"

     ]

 2. The parser will then parse the tokens into the following HsExpr:

       [ HsInterStringRaw ext "Hello "

       , HsInterStringExp ext $

           HsApp ext

 rnExpr (HsOverLit x lit)

   = rnOverLit x lit

   (parts', fvs1) <- unzip <$> mapM rnInterStringPart parts

   pure (expr, plusFVs fvs1 `plusFV` fvs2)

   where

     rnInterStringPart = \case

 {-# LANGUAGE LambdaCase #-}

 module GHC.Rename.String (

   rewriteInterString,

 import GHC.Prelude

 import GHC.Builtin.Names (

   interpolateName,

  )

 import GHC.Builtin.Types (stringTyConName)

 import GHC.Data.FastString (fsLit, unpackFS)

 import GHC.Hs

 import qualified GHC.LanguageExtensions as LangExt

 import GHC.Rename.Pat (rnOverLit)

 import GHC.Tc.Utils.Monad

 import GHC.Types.Name.Set (FreeVars, emptyFVs, plusFVs)

 import GHC.Types.SourceText (SourceText (..))

 import GHC.Types.SrcLoc (unLoc)

 {- Note [Desugaring interpolated strings]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 Interpolated strings are represented with the following HsExpr tree:

       [ HsInterStringRaw ext "Hello "

       , HsInterStringExp ext $

           HsApp ext

 We'll expand this during the renamer phase into the equivalent of:

 We're doing this in the renamer phase so that the expanded expression

 can be typechecked as usual, without any additional work.

 -- necessary.

 --

 -- TODO(bchinn): allow -XRebindableSyntax -- lookupSyntaxName

   overloaded <- xoptM LangExt.OverloadedStrings

   let expr =

   pure (unLoc expr, plusFVs fvs)

   where

       let src = SourceText $ fsLit $ "\"" ++ unpackFS s ++ "\""

 exprCtOrigin (HsIPVar _ ip)       = IPOccOrigin ip

 exprCtOrigin (HsOverLit _ lit)    = LiteralOrigin lit

 exprCtOrigin (HsLit {})           = Shouldn'tHappenOrigin "concrete literal"

 exprCtOrigin (HsLam _ _ ms)       = matchesCtOrigin ms

 exprCtOrigin (HsApp _ e1 _)       = lexprCtOrigin e1

 exprCtOrigin (HsAppType _ e1 _)   = lexprCtOrigin e1

   = do  { lit' <- zonkOverLit lit

         ; return (HsOverLit x lit') }

 zonkExpr (HsLam x lam_variant matches)

   = do new_matches <- zonkMatchGroup zonkLExpr matches

          ; let tele = setTelescopeBndrsNameSpace varName $

                       mkHsForAllVisTele noAnn tvs'

          ; return $ HsForAll noExtField tele body' }

       parts' <- forM parts $ \case

         InterStringRaw s -> pure $ HsInterStringRaw (SourceText $ fsLit s) (fsLit s)

         InterStringExp e -> HsInterStringExpr noExtField <$> cvtl e

 {- | #16895 Ensure an infix expression's operator is a variable/constructor.

 Consider this example:

   | -- | See Note [Parsing interpolated strings]

     HsInterString

       (XInterString p)

       HsStringType

       [HsInterStringPart p]

 pprExp i (ConstrainedE ctx body) =

   parensIf (i >= funPrec) $ sep [pprCtxWith pprExp ctx, pprExp qualPrec body]

   where

     pprInterStringPart = \case

       InterStringRaw s -> text s

       InterStringExp e -> text "${" <> pprExp noPrec e <> text "}"

 https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0570-string-interpolation.rst

 -}

 module Data.String.Interpolate.Experimental (

   Interpolate (..),

 ) where

 import GHC.Internal.Data.String.Interpolate

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

 module GHC.Internal.Data.String.Interpolate (

   Interpolate (..),

 ) where

 import GHC.Internal.Base

 -- | @Interpolate a s@ allows a value of type @a@ to be interpolated

 -- into a string interpolation of type @s@.

 instance Interpolate String String where

   interpolate = id

 instance Interpolate Char String where

   interpolate = interpolate . (:[])

    | ListTuplePuns

    | MultilineStrings

    | StringInterpolation

    | ExplicitLevelImports

    | ImplicitStagePersistence

    deriving (Eq, Enum, Show, Generic, Bounded)

 constrainedE :: Quote m => [m Exp] -> m Exp -> m Exp

 constrainedE ctx body = ConstrainedE <$> sequenceA ctx <*> body

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

 -- *   Dec

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

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

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

   deriving( Show, Eq, Ord, Data, Generic )

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

 -- See Note [Adding a language extension] in compiler/GHC/Driver/Session.hs.

 expectedGhcOnlyExtensions :: [String]

 expectedCabalOnlyExtensions :: [String]

 expectedCabalOnlyExtensions = ["Generics",

 {-# LANGUAGE MultilineStrings #-}

 {-# LANGUAGE OverloadedStrings #-}

 {-# LANGUAGE RecordWildCards #-}

   | SqlInt Int

   deriving (Show)

 instance Interpolate SqlQuery SqlQuery where

 instance Interpolate String SqlQuery where

 instance Interpolate Int SqlQuery where