tcRnExtCore
) where
-#include "HsVersions.h"
-
import IO
#ifdef GHCI
import {-# SOURCE #-} TcSplice ( tcSpliceDecls )
import IfaceSyn
import TcSimplify
import TcTyClsDecls
+import TcUnify ( withBox )
import LoadIface
import RnNames
import RnEnv
import NameEnv
import NameSet
import TyCon
+import TysWiredIn
import SrcLoc
import HscTypes
import ListSetOps
import TcHsType
import TcMType
import TcMatches
-import TcGadt
import RnTypes
import RnExpr
import IfaceEnv
import MkId
-import TysWiredIn
import IdInfo
import {- Kind parts of -} Type
import BasicTypes
-- (b) tcExtCoreBindings doesn't need anything
-- (in fact, it might not even need to be in the scope of
-- this tcg_env at all)
- tcg_env <- importsFromLocalDecls False (mkFakeGroup ldecls)
- emptyUFM {- no fixity decls -} ;
+ avails <- getLocalNonValBinders (mkFakeGroup ldecls) ;
+ tc_envs <- extendGlobalRdrEnvRn False avails
+ emptyFsEnv {- no fixity decls -} ;
- setGblEnv tcg_env $ do {
+ setEnvs tc_envs $ do {
rn_decls <- checkNoErrs $ rnTyClDecls ldecls ;
}}}}
spliceInHsBootErr (SpliceDecl (L loc _), _)
- = addErrAt loc (ptext SLIT("Splices are not allowed in hs-boot files"))
+ = addErrAt loc (ptext (sLit "Splices are not allowed in hs-boot files"))
\end{code}
Once we've typechecked the body of the module, we want to compare what
----------------
missingBootThing thing what
- = ppr thing <+> ptext SLIT("is exported by the hs-boot file, but not")
- <+> text what <+> ptext SLIT("the module")
+ = ppr thing <+> ptext (sLit "is exported by the hs-boot file, but not")
+ <+> text what <+> ptext (sLit "the module")
bootMisMatch thing boot_decl real_decl
- = vcat [ppr thing <+> ptext SLIT("has conflicting definitions in the module and its hs-boot file"),
- ptext SLIT("Main module:") <+> ppr real_decl,
- ptext SLIT("Boot file: ") <+> ppr boot_decl]
+ = vcat [ppr thing <+> ptext (sLit "has conflicting definitions in the module and its hs-boot file"),
+ ptext (sLit "Main module:") <+> ppr real_decl,
+ ptext (sLit "Boot file: ") <+> ppr boot_decl]
instMisMatch inst
= hang (ppr inst)
- 2 (ptext SLIT("is defined in the hs-boot file, but not in the module itself"))
+ 2 (ptext (sLit "is defined in the hs-boot file, but not in the module itself"))
\end{code}
Just main_name -> do
{ traceTc (text "checkMain found" <+> ppr main_mod <+> ppr main_fn)
- ; let { rhs = nlHsApp (nlHsVar runMainIOName) (nlHsVar main_name) }
- -- :Main.main :: IO () = runMainIO main
-
- ; (main_expr, ty) <- addErrCtxt mainCtxt $
- setSrcSpan (srcLocSpan (getSrcLoc main_name)) $
- tcInferRho rhs
+ ; let loc = srcLocSpan (getSrcLoc main_name)
+ ; ioTyCon <- tcLookupTyCon ioTyConName
+ ; (main_expr, res_ty)
+ <- addErrCtxt mainCtxt $
+ withBox liftedTypeKind $ \res_ty ->
+ tcMonoExpr (L loc (HsVar main_name)) (mkTyConApp ioTyCon [res_ty])
-- See Note [Root-main Id]
+ -- Construct the binding
+ -- :Main.main :: IO res_ty = runMainIO res_ty main
+ ; run_main_id <- tcLookupId runMainIOName
; let { root_main_name = mkExternalName rootMainKey rOOT_MAIN
- (mkVarOccFS FSLIT("main"))
+ (mkVarOccFS (fsLit "main"))
(getSrcSpan main_name)
- ; root_main_id = Id.mkExportedLocalId root_main_name ty
- ; main_bind = noLoc (VarBind root_main_id main_expr) }
+ ; root_main_id = Id.mkExportedLocalId root_main_name
+ (mkTyConApp ioTyCon [res_ty])
+ ; co = mkWpTyApps [res_ty]
+ ; rhs = nlHsApp (mkLHsWrap co (nlHsVar run_main_id)) main_expr
+ ; main_bind = noLoc (VarBind root_main_id rhs) }
; return (tcg_env { tcg_binds = tcg_binds tcg_env
`snocBag` main_bind,
-- In other modes, fail altogether, so that we don't go on
-- and complain a second time when processing the export list.
- mainCtxt = ptext SLIT("When checking the type of the") <+> pp_main_fn
- noMainMsg = ptext SLIT("The") <+> pp_main_fn
- <+> ptext SLIT("is not defined in module") <+> quotes (ppr main_mod)
- pp_main_fn | isJust main_is_flag = ptext SLIT("main function") <+> quotes (ppr main_fn)
- | otherwise = ptext SLIT("function") <+> quotes (ppr main_fn)
+ mainCtxt = ptext (sLit "When checking the type of the") <+> pp_main_fn
+ noMainMsg = ptext (sLit "The") <+> pp_main_fn
+ <+> ptext (sLit "is not defined in module") <+> quotes (ppr main_mod)
+ pp_main_fn | isJust main_is_flag = ptext (sLit "main function") <+> quotes (ppr main_fn)
+ | otherwise = ptext (sLit "function") <+> quotes (ppr main_fn)
\end{code}
Note [Root-main Id]
return (global_ids, zonked_expr)
}
where
- bad_unboxed id = addErr (sep [ptext SLIT("GHCi can't bind a variable of unlifted type:"),
+ bad_unboxed id = addErr (sep [ptext (sLit "GHCi can't bind a variable of unlifted type:"),
nest 2 (ppr id <+> dcolon <+> ppr (idType id))])
globaliseAndTidy :: Id -> Id
zonkTcType all_expr_ty
}
where
- smpl_doc = ptext SLIT("main expression")
+ smpl_doc = ptext (sLit "main expression")
\end{code}
tcRnType just finds the kind of a type
return kind
}
where
- doc = ptext SLIT("In GHCi input")
+ doc = ptext (sLit "In GHCi input")
#endif /* GHCi */
\end{code}
-- argument).
tcGetModuleExports :: Module -> [Module] -> TcM [AvailInfo]
tcGetModuleExports mod directlyImpMods
- = do { let doc = ptext SLIT("context for compiling statements")
+ = do { let doc = ptext (sLit "context for compiling statements")
; iface <- initIfaceTcRn $ loadSysInterface doc mod
-- Load any orphan-module and family instance-module
not (isInternalName name),
isTcOcc (nameOccName name), -- Types and classes only
unQualOK gre ] -- In scope unqualified
- doc = ptext SLIT("Need interface for module whose export(s) are in scope unqualified")
+ doc = ptext (sLit "Need interface for module whose export(s) are in scope unqualified")
#endif /* GHCI */
\end{code}
, ppr_fam_insts fam_insts
, vcat (map ppr rules)
, ppr_gen_tycons (typeEnvTyCons type_env)
- , ptext SLIT("Dependent modules:") <+> ppr (eltsUFM (imp_dep_mods imports))
- , ptext SLIT("Dependent packages:") <+> ppr (imp_dep_pkgs imports)]
+ , ptext (sLit "Dependent modules:") <+> ppr (eltsUFM (imp_dep_mods imports))
+ , ptext (sLit "Dependent packages:") <+> ppr (imp_dep_pkgs imports)]
pprModGuts :: ModGuts -> SDoc
pprModGuts (ModGuts { mg_types = type_env,
where
le_sig tycon1 tycon2 = getOccName tycon1 <= getOccName tycon2
ppr_tycon tycon
- | isCoercionTyCon tycon = ptext SLIT("coercion") <+> ppr tycon
+ | isCoercionTyCon tycon = ptext (sLit "coercion") <+> ppr tycon
| otherwise = ppr (tyThingToIfaceDecl (ATyCon tycon))
ppr_rules :: [CoreRule] -> SDoc
ppr_rules [] = empty
-ppr_rules rs = vcat [ptext SLIT("{-# RULES"),
+ppr_rules rs = vcat [ptext (sLit "{-# RULES"),
nest 4 (pprRules rs),
- ptext SLIT("#-}")]
+ ptext (sLit "#-}")]
ppr_gen_tycons [] = empty
-ppr_gen_tycons tcs = vcat [ptext SLIT("Tycons with generics:"),
+ppr_gen_tycons tcs = vcat [ptext (sLit "Tycons with generics:"),
nest 2 (fsep (map ppr (filter tyConHasGenerics tcs)))]
\end{code}