-- Standard modules
import qualified Unsafe.Coerce
-
+import qualified Maybe
-- GHC API
import qualified GHC
import qualified StringBuffer
import qualified MonadUtils
import Outputable ( showSDoc, ppr )
+import qualified Outputable
-- Lexer & Parser, i.e. up to HsExpr
import qualified Lexer
import qualified Parser
import qualified HsTypes
import qualified HsBinds
import qualified TcRnMonad
+import qualified TcRnTypes
import qualified RnExpr
import qualified RnEnv
import qualified TcExpr
import qualified TcEnv
import qualified TcSimplify
+import qualified TcTyFuns
import qualified Desugar
+import qualified InstEnv
+import qualified FamInstEnv
import qualified PrelNames
import qualified Module
import qualified OccName
import qualified RdrName
import qualified Name
+import qualified TysWiredIn
import qualified SrcLoc
+import qualified LoadIface
import qualified BasicTypes
+import qualified Bag
-- Core representation and handling
import qualified CoreSyn
import qualified Id
-- (==) = Prelude.(==) Int $dInt
-- in
-- \x = (==) x 1
-toCore :: HsSyn.HsExpr RdrName.RdrName -> GHC.Ghc CoreSyn.CoreExpr
-toCore expr = do
+toCore ::
+ [Module.ModuleName] -- ^ The modules that need to be imported before translating
+ -- this expression.
+ -> HsSyn.HsExpr RdrName.RdrName -- ^ The expression to translate to Core.
+ -> GHC.Ghc CoreSyn.CoreExpr -- ^ The resulting core expression.
+toCore modules expr = do
env <- GHC.getSession
let icontext = HscTypes.hsc_IC env
-- Translage the TcRn (typecheck-rename) monad into an IO monad
TcRnMonad.initTcPrintErrors env PrelNames.iNTERACTIVE $ do
(tc_expr, insts) <- TcRnMonad.getLIE $ do
+ mapM importModule modules
-- Rename the expression, resulting in a HsExpr Name
(rn_expr, freevars) <- RnExpr.rnExpr expr
-- Typecheck the expression, resulting in a HsExpr Id and a list of
TcEnv.tcLookupId name
return id
+normaliseType ::
+ HscTypes.HscEnv
+ -> Type.Type
+ -> IO Type.Type
+normaliseType env ty = do
+ (err, nty) <- MonadUtils.liftIO $
+ -- Initialize the typechecker monad
+ TcRnMonad.initTcPrintErrors env PrelNames.iNTERACTIVE $ do
+ -- Normalize the type
+ (_, nty) <- TcTyFuns.tcNormaliseFamInst ty
+ return nty
+ let normalized_ty = Maybe.fromJust nty
+ return normalized_ty
+
-- | Translate a core Type to an HsType. Far from complete so far.
coreToHsType :: Type.Type -> HsTypes.LHsType RdrName.RdrName
-- Translate TyConApps
-coreToHsType (Type.splitTyConApp_maybe -> Just (tycon, tys)) =
- foldl (\t a -> SrcLoc.noLoc $ HsTypes.HsAppTy t a) tycon_ty (map coreToHsType tys)
- where
- tycon_name = TyCon.tyConName tycon
- mod_name = Module.moduleName $ Name.nameModule tycon_name
- occ_name = Name.nameOccName tycon_name
- tycon_rdrname = RdrName.mkRdrQual mod_name occ_name
- tycon_ty = SrcLoc.noLoc $ HsTypes.HsTyVar tycon_rdrname
+coreToHsType ty = case Type.splitTyConApp_maybe ty of
+ Just (tycon, tys) ->
+ foldl (\t a -> SrcLoc.noLoc $ HsTypes.HsAppTy t a) tycon_ty (map coreToHsType tys)
+ where
+ tycon_name = TyCon.tyConName tycon
+ mod_name = Module.moduleName $ Name.nameModule tycon_name
+ occ_name = Name.nameOccName tycon_name
+ tycon_rdrname = RdrName.mkRdrQual mod_name occ_name
+ tycon_ty = SrcLoc.noLoc $ HsTypes.HsTyVar tycon_rdrname
+ Nothing -> error $ "HsTools.coreToHsType Cannot translate non-tycon type"
-- | Evaluate a CoreExpr and return its value. For this to work, the caller
-- should already know the result type for sure, since the result value is
let res = Unsafe.Coerce.unsafeCoerce hval :: Int
return $ Unsafe.Coerce.unsafeCoerce hval
--- | Evaluate a core Type representing type level int from the TypeLevel
--- library to a real int.
-eval_type_level_int :: Type.Type -> Int
-eval_type_level_int ty =
- unsafeRunGhc $ do
- -- Automatically import modules for any fully qualified identifiers
- setDynFlag DynFlags.Opt_ImplicitImportQualified
-
- let to_int_name = mkRdrName "Data.TypeLevel.Num.Sets" "toInt"
- let to_int = SrcLoc.noLoc $ HsExpr.HsVar to_int_name
- let undef = hsTypedUndef $ coreToHsType ty
- let app = HsExpr.HsApp (to_int) (undef)
-
- core <- toCore app
- execCore core
-
-- These functions build (parts of) a LHSExpr RdrName.
-- | A reference to the Prelude.undefined function.
let Lexer.POk _ thing = Lexer.unP parser (Lexer.mkPState buf loc dflags)
return thing
+-- | This function imports the module with the given name, for the renamer /
+-- typechecker to use. It also imports any "orphans" and "family instances"
+-- from modules included by this module, but not the actual modules
+-- themselves. I'm not 100% sure how this works, but it seems that any
+-- functions defined in included modules are available just by loading the
+-- original module, and by doing this orphan stuff, any (type family or class)
+-- instances are available as well.
+--
+-- Most of the code is based on tcRnImports and rnImportDecl, but those
+-- functions do a lot more (which I hope we won't need...).
+importModule :: Module.ModuleName -> TcRnTypes.RnM ()
+importModule mod = do
+ let reason = Outputable.text "Hardcoded import" -- Used for trace output
+ let pkg = Nothing
+ -- Load the interface.
+ iface <- LoadIface.loadSrcInterface reason mod False pkg
+ -- Load orphan an familiy instance dependencies as well. I think these
+ -- dependencies are needed for the type checker to know all instances. Any
+ -- other instances (on other packages) are only useful to the
+ -- linker, so we can probably safely ignore them here. Dependencies within
+ -- the same package are also listed in deps, but I'm not so sure what to do
+ -- with them.
+ let deps = HscTypes.mi_deps iface
+ let orphs = HscTypes.dep_orphs deps
+ let finsts = HscTypes.dep_finsts deps
+ LoadIface.loadOrphanModules orphs False
+ LoadIface.loadOrphanModules finsts True