X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypecheck%2FTcRnDriver.lhs;h=c9f03c3c408e094fb9629251bd4b4ccf43b735ea;hb=70349c3260ae22b3e46657150ce144f5de99d8d2;hp=e08dd718e632b139746a8183facf417bf4e36857;hpb=d1429dbd1cc8d65f0ff6451cf22f8eccc03e0acc;p=ghc-hetmet.git diff --git a/ghc/compiler/typecheck/TcRnDriver.lhs b/ghc/compiler/typecheck/TcRnDriver.lhs index e08dd71..c9f03c3 100644 --- a/ghc/compiler/typecheck/TcRnDriver.lhs +++ b/ghc/compiler/typecheck/TcRnDriver.lhs @@ -6,10 +6,10 @@ \begin{code} module TcRnDriver ( #ifdef GHCI - getModuleContents, tcRnStmt, - tcRnGetInfo, GetInfoResult, - tcRnExpr, tcRnType, + tcRnStmt, tcRnExpr, tcRnType, tcRnLookupRdrName, + tcRnLookupName, + tcRnGetInfo, getModuleExports, #endif tcRnModule, @@ -26,15 +26,14 @@ import {-# SOURCE #-} TcSplice ( tcSpliceDecls ) import DynFlags ( DynFlag(..), DynFlags(..), dopt, GhcMode(..) ) import StaticFlags ( opt_PprStyle_Debug ) -import Packages ( moduleToPackageConfig, mkPackageId, package, - isHomeModule ) +import Packages ( checkForPackageConflicts, mkHomeModules ) import HsSyn ( HsModule(..), HsExtCore(..), HsGroup(..), LHsDecl, SpliceDecl(..), HsBind(..), LHsBinds, - emptyGroup, appendGroups, + emptyRdrGroup, emptyRnGroup, appendGroups, plusHsValBinds, nlHsApp, nlHsVar, pprLHsBinds ) import RdrHsSyn ( findSplice ) -import PrelNames ( runMainIOName, rootMainName, mAIN, +import PrelNames ( runMainIOName, rootMainKey, rOOT_MAIN, mAIN, main_RDR_Unqual ) import RdrName ( RdrName, mkRdrUnqual, emptyGlobalRdrEnv ) import TcHsSyn ( zonkTopDecls ) @@ -53,7 +52,7 @@ import TcIface ( tcExtCoreBindings, tcHiBootIface ) import TcSimplify ( tcSimplifyTop ) import TcTyClsDecls ( tcTyAndClassDecls ) import LoadIface ( loadOrphanModules ) -import RnNames ( importsFromLocalDecls, rnImports, exportsFromAvail, +import RnNames ( importsFromLocalDecls, rnImports, rnExports, reportUnusedNames, reportDeprecations ) import RnEnv ( lookupSrcOcc_maybe ) import RnSource ( rnSrcDecls, rnTyClDecls, checkModDeprec ) @@ -64,8 +63,9 @@ import ErrUtils ( Messages, mkDumpDoc, showPass ) import Id ( Id, mkExportedLocalId, isLocalId, idName, idType ) import Var ( Var ) import Module ( Module, ModuleEnv, mkModule, moduleEnvElts, elemModuleEnv ) -import OccName ( mkVarOcc ) -import Name ( Name, NamedThing(..), isExternalName, getSrcLoc, isWiredInName ) +import OccName ( mkVarOcc, mkOccFS, varName ) +import Name ( Name, NamedThing(..), isExternalName, getSrcLoc, isWiredInName, + mkExternalName ) import NameSet import TyCon ( tyConHasGenerics, isSynTyCon, getSynTyConDefn, tyConKind ) import SrcLoc ( srcLocSpan, Located(..), noLoc ) @@ -82,14 +82,15 @@ import HscTypes ( ModGuts(..), ModDetails(..), emptyModDetails, import Outputable #ifdef GHCI -import HsSyn ( HsStmtContext(..), Stmt(..), HsExpr(..), HsBindGroup(..), - LStmt, LHsExpr, LHsType, mkVarBind, +import HsSyn ( HsStmtContext(..), Stmt(..), HsExpr(..), + HsLocalBinds(..), HsValBinds(..), + LStmt, LHsExpr, LHsType, mkVarBind, collectLStmtsBinders, collectLStmtBinders, nlVarPat, placeHolderType, noSyntaxExpr ) import RdrName ( GlobalRdrElt(..), globalRdrEnvElts, unQualOK, lookupLocalRdrEnv, extendLocalRdrEnv ) import RnSource ( addTcgDUs ) -import TcHsSyn ( mkHsLet, zonkTopLExpr, zonkTopBndrs ) +import TcHsSyn ( mkHsDictLet, zonkTopLExpr, zonkTopBndrs ) import TcHsType ( kcHsType ) import TcMType ( zonkTcType, zonkQuantifiedTyVar ) import TcMatches ( tcStmts, tcDoStmt ) @@ -102,36 +103,30 @@ import Inst ( tcGetInstEnvs ) import InstEnv ( classInstances, instEnvElts ) import RnExpr ( rnStmts, rnLExpr ) import LoadIface ( loadSrcInterface, loadSysInterface ) -import IfaceSyn ( IfaceDecl(..), IfaceClassOp(..), IfaceConDecl(..), - IfaceExtName(..), IfaceConDecls(..), - tyThingToIfaceDecl ) -import IfaceType ( IfaceType, toIfaceType, - interactiveExtNameFun ) -import IfaceEnv ( lookupOrig, ifaceExportNames ) -import Module ( lookupModuleEnv, moduleSetElts, mkModuleSet ) +import IfaceEnv ( ifaceExportNames ) +import Module ( moduleSetElts, mkModuleSet ) import RnEnv ( lookupOccRn, dataTcOccs, lookupFixityRn ) -import Id ( isImplicitId, setIdType, globalIdDetails ) +import Id ( setIdType ) import MkId ( unsafeCoerceId ) -import DataCon ( dataConTyCon ) import TyCon ( tyConName ) import TysWiredIn ( mkListTy, unitTy ) import IdInfo ( GlobalIdDetails(..) ) import Kind ( Kind ) import Var ( globaliseId ) -import Name ( nameOccName, nameModule, isBuiltInSyntax, nameParent_maybe ) -import OccName ( occNameUserString, isTcOcc ) +import Name ( nameOccName, nameModule, isBuiltInSyntax ) +import OccName ( isTcOcc ) import NameEnv ( delListFromNameEnv ) import PrelNames ( iNTERACTIVE, ioTyConName, printName, itName, bindIOName, thenIOName, returnIOName ) -import HscTypes ( InteractiveContext(..), HomeModInfo(..), - availNames, availName, ModIface(..), icPrintUnqual, +import HscTypes ( InteractiveContext(..), + ModIface(..), icPrintUnqual, Dependencies(..) ) -import BasicTypes ( RecFlag(..), Fixity ) -import Panic ( ghcError, GhcException(..) ) -import SrcLoc ( SrcLoc, unLoc, noSrcSpan ) +import BasicTypes ( Fixity ) +import SrcLoc ( unLoc, noSrcSpan ) #endif import FastString ( mkFastString ) +import Maybes ( MaybeErr(..) ) import Util ( sortLe ) import Bag ( unionBags, snocBag, emptyBag, unitBag, unionManyBags ) @@ -166,8 +161,6 @@ tcRnModule hsc_env hsc_src save_rn_decls initTc hsc_env hsc_src this_mod $ setSrcSpan loc $ do { - checkForPackageModule (hsc_dflags hsc_env) this_mod; - -- Deal with imports; sets tcg_rdr_env, tcg_imports (rdr_env, imports) <- rnImports import_decls ; @@ -189,13 +182,15 @@ tcRnModule hsc_env hsc_src save_rn_decls -- and any other incrementally-performed imports updateEps_ (\eps -> eps { eps_is_boot = dep_mods }) ; + checkConflicts imports this_mod $ do { + -- Update the gbl env updGblEnv ( \ gbl -> gbl { tcg_rdr_env = rdr_env, tcg_inst_env = extendInstEnvList (tcg_inst_env gbl) home_insts, tcg_imports = tcg_imports gbl `plusImportAvails` imports, tcg_rn_decls = if save_rn_decls then - Just emptyGroup + Just emptyRnGroup else Nothing }) $ do { @@ -228,7 +223,7 @@ tcRnModule hsc_env hsc_src save_rn_decls reportDeprecations tcg_env ; -- Process the export list - exports <- exportsFromAvail (isJust maybe_mod) export_ies ; + exports <- rnExports (isJust maybe_mod) export_ies ; -- Check whether the entire module is deprecated -- This happens only once per module @@ -248,23 +243,27 @@ tcRnModule hsc_env hsc_src save_rn_decls -- Dump output and return tcDump final_env ; return final_env - }}}} - --- This is really a sanity check that the user has given -package-name --- if necessary. -package-name is only necessary when the package database --- already contains the current package, because then we can't tell --- whether a given module is in the current package or not, without knowing --- the name of the current package. -checkForPackageModule dflags this_mod - | not (isHomeModule dflags this_mod), - Just (pkg,_) <- moduleToPackageConfig dflags this_mod = - let - ppr_pkg = ppr (mkPackageId (package pkg)) - in - addErr (ptext SLIT("Module") <+> quotes (ppr this_mod) <+> - ptext SLIT("is a member of package") <+> ppr_pkg <> char '.' $$ - ptext SLIT("To compile this module, please use -ignore-package") <+> ppr_pkg <> char '.') - | otherwise = return () + }}}}} + + +-- The program is not allowed to contain two modules with the same +-- name, and we check for that here. It could happen if the home package +-- contains a module that is also present in an external package, for example. +checkConflicts imports this_mod and_then = do + dflags <- getDOpts + let + dep_mods = this_mod : map fst (moduleEnvElts (imp_dep_mods imports)) + -- don't forget to include the current module! + + mb_dep_pkgs = checkForPackageConflicts + dflags dep_mods (imp_dep_pkgs imports) + -- + case mb_dep_pkgs of + Failed msg -> + do addErr msg; failM + Succeeded _ -> + updGblEnv (\gbl -> gbl{ tcg_home_mods = mkHomeModules dep_mods }) + and_then \end{code} @@ -323,6 +322,7 @@ tcRnExtCore hsc_env (HsExtCore this_mod decls src_binds) mg_usages = [], -- ToDo: compute usage mg_dir_imps = [], -- ?? mg_deps = noDependencies, -- ?? + mg_home_mods = mkHomeModules [], -- ?? wrong!! mg_exports = my_exports, mg_types = final_type_env, mg_insts = tcg_insts tcg_env, @@ -342,10 +342,7 @@ tcRnExtCore hsc_env (HsExtCore this_mod decls src_binds) }}}} mkFakeGroup decls -- Rather clumsy; lots of unused fields - = HsGroup { hs_tyclds = decls, -- This is the one we want - hs_valds = [], hs_fords = [], - hs_instds = [], hs_fixds = [], hs_depds = [], - hs_ruleds = [], hs_defds = [] } + = emptyRdrGroup { hs_tyclds = decls } \end{code} @@ -689,7 +686,7 @@ tcTopSrcDecls boot_details -- We also typecheck any extra binds that came out -- of the "deriving" process (deriv_binds) traceTc (text "Tc5") ; - (tc_val_binds, tcl_env) <- tcTopBinds (val_binds ++ deriv_binds) ; + (tc_val_binds, tcl_env) <- tcTopBinds (val_binds `plusHsValBinds` deriv_binds) ; setLclTypeEnv tcl_env $ do { -- Second pass over class and instance declarations, @@ -729,6 +726,8 @@ tcTopSrcDecls boot_details %************************************************************************ \begin{code} +checkMain :: TcM TcGblEnv +-- If we are in module Main, check that 'main' is defined. checkMain = do { ghci_mode <- getGhciMode ; tcg_env <- getGblEnv ; @@ -745,13 +744,9 @@ checkMain check_main ghci_mode tcg_env main_mod main_fn - -- If we are in module Main, check that 'main' is defined. - -- It may be imported from another module! - -- - -- - -- Blimey: a whole page of code to do this... | mod /= main_mod - = return tcg_env + = traceTc (text "checkMain not" <+> ppr main_mod <+> ppr mod) >> + return tcg_env | otherwise = addErrCtxt mainCtxt $ @@ -759,17 +754,34 @@ check_main ghci_mode tcg_env main_mod main_fn -- Check that 'main' is in scope -- It might be imported from another module! ; case mb_main of { - Nothing -> do { complain_no_main + Nothing -> do { traceTc (text "checkMain fail" <+> ppr main_mod <+> ppr main_fn) + ; complain_no_main ; return tcg_env } ; Just main_name -> do - { let { rhs = nlHsApp (nlHsVar runMainIOName) (nlHsVar main_name) } + { 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) <- setSrcSpan (srcLocSpan (getSrcLoc main_name)) $ tcInferRho rhs - ; let { root_main_id = mkExportedLocalId rootMainName ty ; - main_bind = noLoc (VarBind root_main_id main_expr) } + -- The function that the RTS invokes is always :Main.main, + -- which we call root_main_id. + -- (Because GHC allows the user to have a module not called + -- Main as the main module, we can't rely on the main function + -- being called "Main.main". That's why root_main_id has a fixed + -- module ":Main".) + -- We also make root_main_id an implicit Id, by making main_name + -- its parent (hence (Just main_name)). That has the effect + -- of preventing its type and unfolding from getting out into + -- the interface file. Otherwise we can end up with two defns + -- for 'main' in the interface file! + + ; let { root_main_name = mkExternalName rootMainKey rOOT_MAIN + (mkOccFS varName FSLIT("main")) + (Just main_name) (getSrcLoc main_name) + ; root_main_id = mkExportedLocalId root_main_name ty + ; main_bind = noLoc (VarBind root_main_id main_expr) } ; return (tcg_env { tcg_binds = tcg_binds tcg_env `snocBag` main_bind, @@ -935,11 +947,11 @@ runPlans (p:ps) = tryTcLIE_ (runPlans ps) p -------------------- mkPlan :: LStmt Name -> TcM PlanResult -mkPlan (L loc (ExprStmt expr _ _)) - = do { uniq <- newUnique +mkPlan (L loc (ExprStmt expr _ _)) -- An expression typed at the prompt + = do { uniq <- newUnique -- is treated very specially ; let fresh_it = itName uniq the_bind = mkVarBind noSrcSpan fresh_it expr - let_stmt = L loc $ LetStmt [HsBindGroup (unitBag the_bind) [] NonRecursive] + let_stmt = L loc $ LetStmt (HsValBinds (ValBindsIn (unitBag the_bind) [])) bind_stmt = L loc $ BindStmt (nlVarPat fresh_it) expr (HsVar bindIOName) noSyntaxExpr print_it = L loc $ ExprStmt (nlHsApp (nlHsVar printName) (nlHsVar fresh_it)) @@ -949,18 +961,27 @@ mkPlan (L loc (ExprStmt expr _ _)) -- [it <- e; print it] but not if it::() -- [it <- e] -- [let it = e; print it] - -- [let it = e] - ; runPlans [do { stuff@([it_id], _) <- tcGhciStmts [bind_stmt, print_it] + ; runPlans [ -- Plan A + do { stuff@([it_id], _) <- tcGhciStmts [bind_stmt, print_it] ; it_ty <- zonkTcType (idType it_id) ; ifM (isUnitTy it_ty) failM ; return stuff }, - tcGhciStmts [bind_stmt], - tcGhciStmts [let_stmt, print_it], - tcGhciStmts [let_stmt] + + -- Plan B; a naked bind statment + tcGhciStmts [bind_stmt], + + -- Plan C; check that the let-binding is typeable all by itself. + -- If not, fail; if so, try to print it. + -- The two-step process avoids getting two errors: one from + -- the expression itself, and one from the 'print it' part + -- This two-step story is very clunky, alas + do { checkNoErrs (tcGhciStmts [let_stmt]) + --- checkNoErrs defeats the error recovery of let-bindings + ; tcGhciStmts [let_stmt, print_it] } ]} -mkPlan stmt@(L loc _) - | [L _ v] <- collectLStmtBinders stmt -- One binder +mkPlan stmt@(L loc (BindStmt {})) + | [L _ v] <- collectLStmtBinders stmt -- One binder, for a bind stmt = do { let print_v = L loc $ ExprStmt (nlHsApp (nlHsVar printName) (nlHsVar v)) (HsVar thenIOName) placeHolderType -- The plans are: @@ -972,7 +993,8 @@ mkPlan stmt@(L loc _) ; return stuff }, tcGhciStmts [stmt] ]} - | otherwise + +mkPlan stmt = tcGhciStmts [stmt] --------------------------- @@ -1016,7 +1038,7 @@ tcGhciStmts stmts const_binds <- checkNoErrs (tcSimplifyInteractive lie) ; -- checkNoErrs ensures that the plan fails if context redn fails - return (ids, mkHsLet const_binds $ + return (ids, mkHsDictLet const_binds $ noLoc (HsDo DoExpr tc_stmts (mk_return ids) io_ret_ty)) } \end{code} @@ -1085,9 +1107,13 @@ tcRnType hsc_env ictxt rdr_type \begin{code} #ifdef GHCI -getModuleExports :: HscEnv -> Module -> IO (Maybe NameSet) +-- ASSUMES that the module is either in the HomePackageTable or is +-- a package module with an interface on disk. If neither of these is +-- true, then the result will be an error indicating the interface +-- could not be found. +getModuleExports :: HscEnv -> Module -> IO (Messages, Maybe NameSet) getModuleExports hsc_env mod - = initTcPrintErrors hsc_env iNTERACTIVE (tcGetModuleExports mod) + = initTc hsc_env HsSrcFile iNTERACTIVE (tcGetModuleExports mod) tcGetModuleExports :: Module -> TcM NameSet tcGetModuleExports mod = do @@ -1096,85 +1122,18 @@ tcGetModuleExports mod = do -- Load any orphan-module interfaces, -- so their instances are visible ifaceExportNames (mi_exports iface) -\end{code} -\begin{code} -getModuleContents - :: HscEnv - -> Module -- Module to inspect - -> Bool -- Grab just the exports, or the whole toplev - -> IO (Maybe [IfaceDecl]) - -getModuleContents hsc_env mod exports_only - = initTcPrintErrors hsc_env iNTERACTIVE (get_mod_contents exports_only) - where - get_mod_contents exports_only - | not exports_only -- We want the whole top-level type env - -- so it had better be a home module - = do { hpt <- getHpt - ; case lookupModuleEnv hpt mod of - Just mod_info -> return (map (toIfaceDecl ext_nm) $ - filter wantToSee $ - typeEnvElts $ - md_types (hm_details mod_info)) - Nothing -> ghcError (ProgramError (showSDoc (noRdrEnvErr mod))) - -- This is a system error; the module should be in the HPT - } - - | otherwise -- Want the exports only - = do { iface <- load_iface mod - ; mappM get_decl [ (mod,avail) | (mod, avails) <- mi_exports iface - , avail <- avails ] - } - - get_decl (mod, avail) - = do { main_name <- lookupOrig mod (availName avail) - ; thing <- tcLookupGlobal main_name - ; return (filter_decl (availNames avail) (toIfaceDecl ext_nm thing)) } - - ext_nm = interactiveExtNameFun (icPrintUnqual (hsc_IC hsc_env)) - ---------------------- -filter_decl occs decl@(IfaceClass {ifSigs = sigs}) - = decl { ifSigs = filter (keep_sig occs) sigs } -filter_decl occs decl@(IfaceData {ifCons = IfDataTyCon cons}) - = decl { ifCons = IfDataTyCon (filter (keep_con occs) cons) } -filter_decl occs decl@(IfaceData {ifCons = IfNewTyCon con}) - | keep_con occs con = decl - | otherwise = decl {ifCons = IfAbstractTyCon} -- Hmm? -filter_decl occs decl - = decl - -keep_sig occs (IfaceClassOp occ _ _) = occ `elem` occs -keep_con occs con = ifConOcc con `elem` occs - -wantToSee (AnId id) = not (isImplicitId id) -wantToSee (ADataCon _) = False -- They'll come via their TyCon -wantToSee _ = True - ---------------------- load_iface mod = loadSrcInterface doc mod False {- Not boot iface -} where doc = ptext SLIT("context for compiling statements") ---------------------- -noRdrEnvErr mod = ptext SLIT("No top-level environment available for module") - <+> quotes (ppr mod) -\end{code} - -\begin{code} -type GetInfoResult = (String, IfaceDecl, Fixity, SrcLoc, - [(IfaceType,SrcLoc)] -- Instances - ) tcRnLookupRdrName :: HscEnv -> RdrName -> IO (Maybe [Name]) - tcRnLookupRdrName hsc_env rdr_name = initTcPrintErrors hsc_env iNTERACTIVE $ setInteractiveContext hsc_env (hsc_IC hsc_env) $ lookup_rdr_name rdr_name - lookup_rdr_name rdr_name = do { -- If the identifier is a constructor (begins with an -- upper-case letter), then we need to consider both @@ -1205,10 +1164,16 @@ lookup_rdr_name rdr_name = do { } +tcRnLookupName :: HscEnv -> Name -> IO (Maybe TyThing) +tcRnLookupName hsc_env name + = initTcPrintErrors hsc_env iNTERACTIVE $ + setInteractiveContext hsc_env (hsc_IC hsc_env) $ + tcLookupGlobal name + + tcRnGetInfo :: HscEnv - -> InteractiveContext - -> RdrName - -> IO (Maybe [GetInfoResult]) + -> Name + -> IO (Maybe (TyThing, Fixity, [Instance])) -- Used to implemnent :info in GHCi -- @@ -1217,51 +1182,22 @@ tcRnGetInfo :: HscEnv -- but we want to treat it as *both* a data constructor -- *and* as a type or class constructor; -- hence the call to dataTcOccs, and we return up to two results -tcRnGetInfo hsc_env ictxt rdr_name +tcRnGetInfo hsc_env name = initTcPrintErrors hsc_env iNTERACTIVE $ - setInteractiveContext hsc_env ictxt $ do { + let ictxt = hsc_IC hsc_env in + setInteractiveContext hsc_env ictxt $ do -- Load the interface for all unqualified types and classes -- That way we will find all the instance declarations -- (Packages have not orphan modules, and we assume that -- in the home package all relevant modules are loaded.) - loadUnqualIfaces ictxt ; - - good_names <- lookup_rdr_name rdr_name ; - - -- And lookup up the entities, avoiding duplicates, which arise - -- because constructors and record selectors are represented by - -- their parent declaration - let { do_one name = do { thing <- tcLookupGlobal name - ; fixity <- lookupFixityRn name - ; ispecs <- lookupInsts print_unqual thing - ; return (str, toIfaceDecl ext_nm thing, fixity, - getSrcLoc thing, - [(toIfaceType ext_nm (idType dfun), getSrcLoc dfun) - | dfun <- map instanceDFunId ispecs ] - ) } - where - -- str is the the naked occurrence name - -- after stripping off qualification and parens (+) - str = occNameUserString (nameOccName name) - - ; parent_is_there n - | Just p <- nameParent_maybe n = p `elem` good_names - | otherwise = False - } ; - - -- For the SrcLoc, the 'thing' has better info than - -- the 'name' because getting the former forced the - -- declaration to be loaded into the cache - - mapM do_one (filter (not . parent_is_there) good_names) - -- Filter out names whose parent is also there - -- Good example is '[]', which is both a type and data constructor - -- in the same type - } - where - ext_nm = interactiveExtNameFun print_unqual - print_unqual = icPrintUnqual ictxt + loadUnqualIfaces ictxt + + thing <- tcLookupGlobal name + fixity <- lookupFixityRn name + ispecs <- lookupInsts (icPrintUnqual ictxt) thing + return (thing, fixity, ispecs) + lookupInsts :: PrintUnqualified -> TyThing -> TcM [Instance] -- Filter the instances by the ones whose tycons (or clases resp) @@ -1295,18 +1231,6 @@ plausibleDFun print_unqual dfun -- Dfun involving only names that print unqualif | isExternalName name = print_unqual (nameModule name) (nameOccName name) | otherwise = True -toIfaceDecl :: (Name -> IfaceExtName) -> TyThing -> IfaceDecl -toIfaceDecl ext_nm thing - = tyThingToIfaceDecl ext_nm (munge thing) - where - -- munge transforms a thing to its "parent" thing - munge (ADataCon dc) = ATyCon (dataConTyCon dc) - munge (AnId id) = case globalIdDetails id of - RecordSelId tc lbl -> ATyCon tc - ClassOpId cls -> AClass cls - other -> AnId id - munge other_thing = other_thing - loadUnqualIfaces :: InteractiveContext -> TcM () -- Load the home module for everything that is in scope unqualified -- This is so that we can accurately report the instances for