Commit bf3b2932 authored by Simon Peyton Jones's avatar Simon Peyton Jones

Tidy up the error messages we get from TH in stage1 (Trac #8312)

Instead of panic-ing we now give a sensible message.
There is quite a bit of refactoring here too, removing
several #ifdef GHCI things
parent 5bf435bd
......@@ -387,6 +387,7 @@ Library
TcCanonical
TcSMonad
TcTypeNats
TcSplice
Class
Coercion
FamInstEnv
......@@ -532,7 +533,6 @@ Library
if flag(ghci)
Exposed-Modules:
DsMeta
TcSplice
Convert
ByteCodeAsm
ByteCodeGen
......
......@@ -16,9 +16,7 @@ module RnExpr (
#include "HsVersions.h"
#ifdef GHCI
import {-# SOURCE #-} TcSplice( runQuasiQuoteExpr )
#endif /* GHCI */
import RnBinds ( rnLocalBindsAndThen, rnLocalValBindsLHS, rnLocalValBindsRHS,
rnMatchGroup, rnGRHS, makeMiniFixityEnv)
......@@ -179,15 +177,12 @@ rnExpr e@(HsBracket br_body) = rnBracket e br_body
rnExpr (HsSpliceE splice) = rnSpliceExpr splice
#ifndef GHCI
rnExpr e@(HsQuasiQuoteE _) = pprPanic "Cant do quasiquotation without GHCi" (ppr e)
#else
rnExpr (HsQuasiQuoteE qq)
= runQuasiQuoteExpr qq `thenM` \ lexpr' ->
-- Wrap the result of the quasi-quoter in parens so that we don't
-- lose the outermost location set by runQuasiQuote (#7918)
rnExpr (HsPar lexpr')
#endif /* GHCI */
---------------------------------------------
-- Sections
......
......@@ -39,10 +39,8 @@ module RnPat (-- main entry points
-- ENH: thin imports to only what is necessary for patterns
import {-# SOURCE #-} RnExpr ( rnLExpr )
#ifdef GHCI
import {-# SOURCE #-} RnSplice ( rnSplicePat )
import {-# SOURCE #-} TcSplice ( runQuasiQuotePat )
#endif /* GHCI */
#include "HsVersions.h"
......@@ -424,22 +422,15 @@ rnPatAndThen mk (TuplePat pats boxed _)
; pats' <- rnLPatsAndThen mk pats
; return (TuplePat pats' boxed placeHolderType) }
#ifndef GHCI
rnPatAndThen _ p@(SplicePat {})
= pprPanic "Can't do SplicePat without GHCi" (ppr p)
rnPatAndThen _ p@(QuasiQuotePat {})
= pprPanic "Can't do QuasiQuotePat without GHCi" (ppr p)
#else
rnPatAndThen _ (SplicePat splice)
= do { -- XXX How to deal with free variables?
(pat, _) <- liftCps $ rnSplicePat splice
; (pat, _) <- liftCps $ rnSplicePat splice
; return pat }
rnPatAndThen mk (QuasiQuotePat qq)
= do { pat <- liftCps $ runQuasiQuotePat qq
-- Wrap the result of the quasi-quoter in parens so that we don't
-- lose the outermost location set by runQuasiQuote (#7918)
; rnPatAndThen mk (ParPat pat) }
#endif /* GHCI */
rnPatAndThen _ pat = pprPanic "rnLPatAndThen" (ppr pat)
......
......@@ -12,9 +12,7 @@ module RnSource (
import {-# SOURCE #-} RnExpr( rnLExpr )
import {-# SOURCE #-} RnSplice ( rnSpliceDecl )
#ifdef GHCI
import {-# SOURCE #-} TcSplice ( runQuasiQuoteDecl )
#endif /* GHCI */
import HsSyn
import RdrName
......@@ -1475,14 +1473,9 @@ add gp loc (SpliceD splice@(SpliceDecl _ flag)) ds
where
badImplicitSplice = ptext (sLit "Parse error: naked expression at top level")
#ifndef GHCI
add _ _ (QuasiQuoteD qq) _
= pprPanic "Can't do QuasiQuote declarations without GHCi" (ppr qq)
#else
add gp _ (QuasiQuoteD qq) ds -- Expand quasiquotes
= do { ds' <- runQuasiQuoteDecl qq
; addl gp (ds' ++ ds) }
#endif
-- Class declarations: pull out the fixity signatures to the top
add gp@(HsGroup {hs_tyclds = ts, hs_fixds = fs}) l (TyClD d) ds
......
......@@ -5,11 +5,10 @@ module RnSplice (
checkThLocalName
) where
import FastString
import Name
import NameSet
import HsSyn
import Outputable
import RdrName
import TcRnMonad
......@@ -25,6 +24,8 @@ import RnSource ( rnSrcDecls, findSplice )
import RnTypes
import SrcLoc
import TcEnv ( checkWellStaged, tcLookup, tcMetaTy, thTopLevelId )
import Outputable
import FastString
import {-# SOURCE #-} RnExpr ( rnLExpr )
import {-# SOURCE #-} TcExpr ( tcMonoExpr )
......@@ -35,29 +36,22 @@ import {-# SOURCE #-} TcSplice ( runMetaE, runMetaP, runMetaT, tcTopSpliceExpr )
\begin{code}
#ifndef GHCI
rnBracket :: HsExpr RdrName -> HsBracket RdrName -> RnM (HsExpr Name, FreeVars)
rnBracket e _ = failTH e "bracket"
rnBracket e _ = failTH e "Template Haskell bracket"
rnSplice :: HsSplice RdrName -> RnM (HsSplice Name, FreeVars)
rnSplice e = failTH e "splice"
rnSplice e = failTH e "Template Haskell splice"
rnSpliceType :: HsSplice RdrName -> PostTcKind -> RnM (HsType Name, FreeVars)
rnSpliceType e _ = failTH e "splice"
rnSpliceType e _ = failTH e "Template Haskell type splice"
rnSpliceExpr :: HsSplice RdrName -> RnM (HsExpr Name, FreeVars)
rnSpliceExpr e = failTH e "splice"
rnSpliceExpr e = failTH e "Template Haskell splice"
rnSplicePat :: HsSplice RdrName -> RnM (Pat Name, FreeVars)
rnSplicePat e = failTH e "splice"
rnSplicePat e = failTH e "Template Haskell pattern splice"
rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)
rnSpliceDecl e = failTH e "splice"
failTH :: Outputable a => a -> String -> RnM b
failTH e what -- Raise an error in a stage-1 compiler
= failWithTc (vcat [ptext (sLit "Template Haskell") <+> text what <+>
ptext (sLit "requires GHC with interpreter support"),
ptext (sLit "Perhaps you are using a stage-1 compiler?"),
nest 2 (ppr e)])
rnSpliceDecl e = failTH e "Template Haskell declaration splice"
#else
\end{code}
......@@ -89,7 +83,7 @@ type checker. Not very satisfactory really.
\begin{code}
rnSplice :: HsSplice RdrName -> RnM (HsSplice Name, FreeVars)
rnSplice (HsSplice isTyped n expr)
= do { checkTH expr "splice"
= do { checkTH expr "Template Haskell splice"
; loc <- getSrcSpanM
; n' <- newLocalBndrRn (L loc n)
; (expr', fvs) <- rnLExpr expr
......@@ -124,13 +118,13 @@ rnSpliceType splice@(HsSplice isTypedSplice _ expr) k
-- ToDo: deal with fvs
; (splice'@(HsSplice _ name expr'), fvs) <- setStage pop_stage $
rnSplice splice
; ps <- readMutVar ps_var
; writeMutVar ps_var (PendingRnTypeSplice name expr' : ps)
; return (HsSpliceTy splice' fvs k, fvs)
}
; _ ->
; _ ->
do { -- ToDo: deal with fvs
(splice', fvs) <- addErrCtxt (spliceResultDoc expr) $
setStage (Splice isTypedSplice) $
......@@ -144,7 +138,7 @@ rnSpliceType splice@(HsSplice isTypedSplice _ expr) k
maybeExpandTopSplice splice@(HsSplice True _ _) fvs
= return (HsSpliceTy splice fvs k, fvs)
maybeExpandTopSplice (HsSplice False _ expr) _
maybeExpandTopSplice (HsSplice False _ expr) _
= do { -- The splice must have type TypeQ
; meta_exp_ty <- tcMetaTy typeQTyConName
......@@ -180,13 +174,13 @@ rnSpliceExpr splice@(HsSplice isTypedSplice _ expr)
; (splice'@(HsSplice _ name expr'), fvs) <- setStage pop_stage $
rnSplice splice
; ps <- readMutVar ps_var
; writeMutVar ps_var (PendingRnExpSplice name expr' : ps)
; return (HsSpliceE splice', fvs)
}
; _ ->
; _ ->
do { (splice', fvs) <- addErrCtxt (spliceResultDoc expr) $
setStage (Splice isTypedSplice) $
rnSplice splice
......@@ -199,7 +193,7 @@ rnSpliceExpr splice@(HsSplice isTypedSplice _ expr)
maybeExpandTopSplice splice@(HsSplice True _ _) fvs
= return (HsSpliceE splice, fvs)
maybeExpandTopSplice (HsSplice False _ expr) _
maybeExpandTopSplice (HsSplice False _ expr) _
= do { -- The splice must have type ExpQ
; meta_exp_ty <- tcMetaTy expQTyConName
......@@ -307,7 +301,7 @@ rnBracket e br_body
; unless thEnabled $
failWith ( vcat [ ptext (sLit "Syntax error on") <+> ppr e
, ptext (sLit "Perhaps you intended to use TemplateHaskell") ] )
; checkTH e "bracket"
; checkTH e "Template Haskell bracket"
-- Check for nested brackets
; cur_stage <- getStage
......@@ -469,19 +463,6 @@ spliceResultDoc expr
#endif
\end{code}
\begin{code}
checkTH :: Outputable a => a -> String -> RnM ()
#ifdef GHCI
checkTH _ _ = return () -- OK
#else
checkTH e what -- Raise an error in a stage-1 compiler
= addErr (vcat [ptext (sLit "Template Haskell") <+> text what <+>
ptext (sLit "requires GHC with interpreter support"),
ptext (sLit "Perhaps you are using a stage-1 compiler?"),
nest 2 (ppr e)])
#endif
\end{code}
\begin{code}
checkThLocalName :: Name -> ThLevel -> RnM ()
#ifndef GHCI /* GHCI and TH is off */
......
......@@ -7,8 +7,6 @@ import RdrName
import Name
import NameSet
import Outputable
rnBracket :: HsExpr RdrName -> HsBracket RdrName -> RnM (HsExpr Name, FreeVars)
rnSplice :: HsSplice RdrName -> RnM (HsSplice Name, FreeVars)
......@@ -16,6 +14,4 @@ rnSpliceType :: HsSplice RdrName -> PostTcKind -> RnM (HsType Name, FreeVars)
rnSpliceExpr :: HsSplice RdrName -> RnM (HsExpr Name, FreeVars)
rnSplicePat :: HsSplice RdrName -> RnM (Pat Name, FreeVars)
rnSpliceDecl :: SpliceDecl RdrName -> RnM (SpliceDecl Name, FreeVars)
checkTH :: Outputable a => a -> String -> RnM ()
\end{code}
......@@ -21,9 +21,7 @@ module RnTypes (
extractRdrKindSigVars, extractDataDefnKindVars, filterInScope
) where
#ifdef GHCI
import {-# SOURCE #-} TcSplice( runQuasiQuoteType )
#endif /* GHCI */
import {-# SOURCE #-} RnSplice( rnSpliceType )
import DynFlags
......@@ -261,16 +259,12 @@ rnHsTyKi isType doc (HsDocTy ty haddock_doc)
; haddock_doc' <- rnLHsDoc haddock_doc
; return (HsDocTy ty' haddock_doc', fvs) }
#ifndef GHCI
rnHsTyKi _ _ ty@(HsQuasiQuoteTy _) = pprPanic "Can't do quasiquotation without GHCi" (ppr ty)
#else
rnHsTyKi isType doc (HsQuasiQuoteTy qq)
= ASSERT( isType )
do { ty <- runQuasiQuoteType qq
-- Wrap the result of the quasi-quoter in parens so that we don't
-- lose the outermost location set by runQuasiQuote (#7918)
; rnHsType doc (HsParTy ty) }
#endif
rnHsTyKi isType _ (HsCoreTy ty)
= ASSERT( isType )
......
......@@ -7,6 +7,8 @@
\begin{code}
module TcAnnotations ( tcAnnotations ) where
import {-# SOURCE #-} TcSplice ( runAnnotation )
import HsSyn
import Annotations
import Name
......@@ -14,12 +16,9 @@ import TcRnMonad
import SrcLoc
import Outputable
#ifdef GHCI
import Module
import TcExpr
import {-# SOURCE #-} TcSplice ( runAnnotation )
import FastString
#endif
\end{code}
\begin{code}
......@@ -27,15 +26,11 @@ tcAnnotations :: [LAnnDecl Name] -> TcM [Annotation]
tcAnnotations = mapM tcAnnotation
tcAnnotation :: LAnnDecl Name -> TcM Annotation
#ifndef GHCI
-- TODO: modify lexer so ANN pragmas are parsed as comments in a stage1 compiler, so developers don't see this error
tcAnnotation (L _ (HsAnnotation _ expr)) = pprPanic "Cant do annotations without GHCi" (ppr expr)
#else
tcAnnotation ann@(L loc (HsAnnotation provenance expr)) = do
-- Work out what the full target of this annotation was
mod <- getModule
let target = annProvenanceToTarget mod provenance
-- Run that annotation and construct the full Annotation data structure
setSrcSpan loc $ addErrCtxt (annCtxt ann) $ addExprErrCtxt expr $ runAnnotation target expr
......@@ -47,5 +42,4 @@ annProvenanceToTarget mod ModuleAnnProvenance = ModuleTarget mod
annCtxt :: OutputableBndr id => LAnnDecl id -> SDoc
annCtxt ann
= hang (ptext (sLit "In the annotation:")) 2 (ppr ann)
#endif
\end{code}
\ No newline at end of file
......@@ -12,9 +12,9 @@ module TcExpr ( tcPolyExpr, tcPolyExprNC, tcMonoExpr, tcMonoExprNC,
#include "HsVersions.h"
#ifdef GHCI /* Only if bootstrapped */
import {-# SOURCE #-} TcSplice( tcSpliceExpr, tcBracket )
import qualified DsMeta
#ifdef GHCI
import DsMeta( liftStringName, liftName )
#endif
import HsSyn
......@@ -797,7 +797,6 @@ tcExpr (PArrSeq _ _) _
%************************************************************************
\begin{code}
#ifdef GHCI /* Only if bootstrapped */
-- Rename excludes these cases otherwise
tcExpr (HsSpliceE splice) res_ty = tcSpliceExpr splice res_ty
tcExpr (HsRnBracketOut brack ps) res_ty = tcBracket brack ps res_ty
......@@ -805,7 +804,6 @@ tcExpr e@(HsBracketOut _ _) _ =
pprPanic "Should never see HsBracketOut in type checker" (ppr e)
tcExpr e@(HsQuasiQuoteE _) _ =
pprPanic "Should never see HsQuasiQuoteE in type checker" (ppr e)
#endif /* GHCI */
\end{code}
......@@ -1339,6 +1337,10 @@ checkCrossStageLifting id _ (Brack _ _ ps_var lie_var)
; writeMutVar ps_var (PendingTcSplice (idName id) (nlHsApp (noLoc lift) (nlHsVar id)) : ps)
; return () }
polySpliceErr :: Id -> SDoc
polySpliceErr id
= ptext (sLit "Can't splice the polymorphic local variable") <+> quotes (ppr id)
#endif /* GHCI */
\end{code}
......@@ -1616,10 +1618,4 @@ missingFields con fields
<+> pprWithCommas ppr fields
-- callCtxt fun args = ptext (sLit "In the call") <+> parens (ppr (foldl mkHsApp fun args))
#ifdef GHCI
polySpliceErr :: Id -> SDoc
polySpliceErr id
= ptext (sLit "Can't splice the polymorphic local variable") <+> quotes (ppr id)
#endif
\end{code}
......@@ -41,10 +41,6 @@ module TcHsType (
#include "HsVersions.h"
#ifdef GHCI /* Only if bootstrapped */
import {-# SOURCE #-} TcSplice( tcSpliceType )
#endif
import HsSyn
import TcRnMonad
import TcEvidence( HsWrapper )
......@@ -509,31 +505,19 @@ tc_hs_type (HsCoreTy ty) exp_kind
; return ty }
#ifdef GHCI /* Only if bootstrapped */
-- This looks highly suspect to me
-- It will really only be fixed properly when we do the TH
-- reorganisation so that type splices happen in the renamer
tc_hs_type hs_ty@(HsSpliceTy sp fvs _) exp_kind
= do { s <- getStage
; traceTc "tc_hs_type: splice" (ppr sp $$ ppr s)
; (ty, kind) <- tcSpliceType sp fvs
; checkExpectedKind hs_ty kind exp_kind
-- -- See Note [Kind of a type splice]
; return ty }
#else
tc_hs_type ty@(HsSpliceTy {}) _exp_kind
-- This should never happen; type splices are expanded by the renamer
tc_hs_type ty@(HsSpliceTy {}) _exp_kind
= failWithTc (ptext (sLit "Unexpected type splice:") <+> ppr ty)
#endif
tc_hs_type (HsWrapTy {}) _exp_kind
tc_hs_type (HsWrapTy {}) _exp_kind
= panic "tc_hs_type HsWrapTy" -- We kind checked something twice
tc_hs_type hs_ty@(HsTyLit (HsNumTy n)) exp_kind
tc_hs_type hs_ty@(HsTyLit (HsNumTy n)) exp_kind
= do { checkExpectedKind hs_ty typeNatKind exp_kind
; checkWiredInTyCon typeNatKindCon
; return (mkNumLitTy n) }
tc_hs_type hs_ty@(HsTyLit (HsStrTy s)) exp_kind
tc_hs_type hs_ty@(HsTyLit (HsStrTy s)) exp_kind
= do { checkExpectedKind hs_ty typeSymbolKind exp_kind
; checkWiredInTyCon typeSymbolKindCon
; return (mkStrLitTy s) }
......
......@@ -828,6 +828,20 @@ ifErrsM bale_out normal
failIfErrsM :: TcRn ()
-- Useful to avoid error cascades
failIfErrsM = ifErrsM failM (return ())
checkTH :: Outputable a => a -> String -> TcRn ()
#ifdef GHCI
checkTH _ _ = return () -- OK
#else
checkTH e what = failTH e what -- Raise an error in a stage-1 compiler
#endif
failTH :: Outputable a => a -> String -> TcRn x
failTH e what -- Raise an error in a stage-1 compiler
= failWithTc (vcat [ text what
<+> ptext (sLit "requires GHC with interpreter support")
, ptext (sLit "Perhaps you are using a stage-1 compiler?")
, nest 2 (ppr e)])
\end{code}
......
......@@ -9,26 +9,40 @@ TcSplice: Template Haskell splices
\begin{code}
{-# LANGUAGE ScopedTypeVariables #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module TcSplice( tcSpliceType, tcSpliceExpr, tcSpliceDecls, tcBracket,
tcTopSpliceExpr,
lookupThName_maybe,
runQuasiQuoteExpr, runQuasiQuotePat,
runQuasiQuoteDecl, runQuasiQuoteType,
runAnnotation,
runQuasi, runMetaE, runMetaP, runMetaT, runMetaD ) where
module TcSplice(
-- These functions are defined in stage1 and stage2
-- The raise civilised errors in stage1
tcSpliceExpr, tcSpliceDecls, tcBracket,
runQuasiQuoteExpr, runQuasiQuotePat,
runQuasiQuoteDecl, runQuasiQuoteType,
runAnnotation,
#ifdef GHCI
-- These ones are defined only in stage2, and are
-- called only in stage2 (ie GHCI is on)
runMetaE, runMetaP, runMetaT, runMetaD, runQuasi,
tcTopSpliceExpr, lookupThName_maybe,
#endif
) where
#include "HsVersions.h"
import HsSyn
import Annotations
import Name
import TcRnMonad
import RdrName
import TcType
#ifdef GHCI
import HscMain
-- These imports are the reason that TcSplice
-- is very high up the module hierarchy
import HscTypes
import HsSyn
import Convert
import RnExpr
import RnEnv
import RdrName
import RnTypes
import TcExpr
import TcHsSyn
......@@ -36,7 +50,7 @@ import TcSimplify
import TcUnify
import Type
import Kind
import TcType
import NameSet
import TcEnv
import TcMType
import TcHsType
......@@ -45,16 +59,12 @@ import TypeRep
import FamInst
import FamInstEnv
import InstEnv
import Name
import NameEnv
import NameSet
import PrelNames
import OccName
import Hooks
import Var
import Module
import Annotations
import TcRnMonad
import LoadIface
import Class
import Inst
......@@ -64,13 +74,11 @@ import DataCon
import TcEvidence( TcEvBinds(..) )
import Id
import IdInfo
import DsMeta
import DsExpr
import DsMonad hiding (Splice)
import Serialized
import ErrUtils
import SrcLoc
import Outputable
import Util
import Data.List ( mapAccumL )
import Unique
......@@ -80,25 +88,60 @@ import Maybes( MaybeErr(..) )
import DynFlags
import Panic
import FastString
import Outputable
import Control.Monad ( when )
import DsMeta
import qualified Language.Haskell.TH as TH
-- THSyntax gives access to internal functions and data types
import qualified Language.Haskell.TH.Syntax as TH
#ifdef GHCI
-- Because GHC.Desugar might not be in the base library of the bootstrapping compiler
import GHC.Desugar ( AnnotationWrapper(..) )
import qualified Data.Map as Map
import Data.Dynamic ( fromDynamic, toDyn )
import Data.Typeable ( typeOf )
#endif
import Data.Data (Data)
import GHC.Exts ( unsafeCoerce# )
#endif
\end{code}
%************************************************************************
%* *
\subsection{Main interface + stubs for the non-GHCI case
%* *
%************************************************************************
\begin{code}
tcBracket :: HsBracket Name -> [PendingSplice] -> TcRhoType -> TcM (HsExpr TcId)
tcSpliceDecls :: HsSplice Name -> TcM [LHsDecl RdrName]
tcSpliceExpr :: HsSplice Name -> TcRhoType -> TcM (HsExpr TcId)
-- None of these functions add constraints to the LIE
runQuasiQuoteExpr :: HsQuasiQuote RdrName -> RnM (LHsExpr RdrName)
runQuasiQuotePat :: HsQuasiQuote RdrName -> RnM (LPat RdrName)
runQuasiQuoteType :: HsQuasiQuote RdrName -> RnM (LHsType RdrName)
runQuasiQuoteDecl :: HsQuasiQuote RdrName -> RnM [LHsDecl RdrName]
runAnnotation :: CoreAnnTarget -> LHsExpr Name -> TcM Annotation
#ifndef GHCI
tcBracket x _ _ = failTH x "Template Haskell bracket"
tcSpliceExpr e _ = failTH e "Template Haskell splice"
tcSpliceDecls x = failTH x "Template Haskell declaration splice"
runQuasiQuoteExpr q = failTH q "quasiquote"
runQuasiQuotePat q = failTH q "pattern quasiquote"
runQuasiQuoteType q = failTH q "type quasiquote"
runQuasiQuoteDecl q = failTH q "declaration quasiquote"
runAnnotation _ q = failTH q "annotation"
#else
-- The whole of the rest of the file is the else-branch (ie stage2 only)
\end{code}
Note [How top-level splices are handled]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Top-level splices (those not inside a [| .. |] quotation bracket) are handled
......@@ -286,46 +329,6 @@ Note [Interactively-bound Ids in GHCi] in TcRnDriver.)
The predicate we use is TcEnv.thTopLevelId.
%************************************************************************
%* *
\subsection{Main interface + stubs for the non-GHCI case
%* *
%************************************************************************
\begin{code}
tcBracket :: HsBracket Name -> [PendingSplice] -> TcRhoType -> TcM (HsExpr TcId)
tcSpliceDecls :: HsSplice Name -> TcM [LHsDecl RdrName]
tcSpliceExpr :: HsSplice Name -> TcRhoType -> TcM (HsExpr TcId)
tcSplicePat :: HsSplice Name -> TcRhoType -> TcM (HsExpr TcId)
tcSpliceType :: HsSplice Name -> FreeVars -> TcM (TcType, TcKind)
-- None of these functions add constraints to the LIE
lookupThName_maybe :: TH.Name -> TcM (Maybe Name)
runQuasiQuoteExpr :: HsQuasiQuote RdrName -> RnM (LHsExpr RdrName)
runQuasiQuotePat :: HsQuasiQuote RdrName -> RnM (LPat RdrName)
runQuasiQuoteType :: HsQuasiQuote RdrName -> RnM (LHsType RdrName)
runQuasiQuoteDecl :: HsQuasiQuote RdrName -> RnM [LHsDecl RdrName]
runAnnotation :: CoreAnnTarget -> LHsExpr Name -> TcM Annotation
#ifndef GHCI
tcBracket x _ _ = pprPanic "Cant do tcBracket without GHCi" (ppr x)
tcSpliceExpr e = pprPanic "Cant do tcSpliceExpr without GHCi" (ppr e)
tcSplicePat e = pprPanic "Cant do tcSplicePat without GHCi" (ppr e)
tcSpliceDecls x = pprPanic "Cant do tcSpliceDecls without GHCi" (ppr x)
tcSpliceType x fvs = pprPanic "Cant do kcSpliceType without GHCi" (ppr x)
lookupThName_maybe n = pprPanic "Cant do lookupThName_maybe without GHCi" (ppr n)
runQuasiQuoteExpr q = pprPanic "Cant do runQuasiQuoteExpr without GHCi" (ppr q)
runQuasiQuotePat q = pprPanic "Cant do runQuasiQuotePat without GHCi" (ppr q)
runQuasiQuoteType q = pprPanic "Cant do runQuasiQuoteType without GHCi" (ppr q)
runQuasiQuoteDecl q = pprPanic "Cant do runQuasiQuoteDecl without GHCi" (ppr q)
runAnnotation _ q = pprPanic "Cant do runAnnotation without GHCi" (ppr q)
#else
\end{code}
%************************************************************************
%* *
\subsection{Quoting an expression}
......@@ -526,6 +529,7 @@ tcTopSplice expr res_ty
%************************************************************************
\begin{code}
tcSplicePat :: HsSplice Name -> TcRhoType -> TcM (HsExpr TcId)
tcSplicePat splice@(HsSplice True _ _) _
= pprPanic "tcSplicePat: encountered typed pattern splice" (ppr splice)
......@@ -623,6 +627,7 @@ We don't want the type checker to see these bogus unbound variables.
Very like splicing an expression, but we don't yet share code.
\begin{code}
tcSpliceType :: HsSplice Name -> FreeVars -> TcM (TcType, TcKind)
tcSpliceType splice@(HsSplice True _ _) _
= pprPanic "tcSpliceType: encountered a typed type splice" (ppr splice)
......@@ -1151,7 +1156,6 @@ illegalTypedSplice = ptext (sLit "Typed splices may not appear in untyped bracke
illegalUntypedSplice :: SDoc
illegalUntypedSplice = ptext (sLit "Untyped splices may not appear in typed brackets")
#endif /* GHCI */
\end{code}
......@@ -1261,6 +1265,7 @@ lookupThName th_name = do
Nothing -> failWithTc (notInScope th_name)
Just name -> return name
lookupThName_maybe :: TH.Name -> TcM (Maybe Name)
lookupThName_maybe th_name
= do { names <- mapMaybeM lookup (thRdrNameGuesses th_name)
-- Pick the first that works
......@@ -1729,3 +1734,6 @@ will appear in TH syntax like this
data T a = forall b. (a ~ [b]) => MkT1 b
| (a ~ Int) => MkT2