#include "HsVersions.h"
#ifdef GHCI
+import Interpreter
import ByteCodeGen ( byteCodeGen )
import CoreTidy ( tidyCoreExpr )
import CorePrep ( corePrepExpr )
import Rename ( renameStmt, renameRdrName )
-import RdrName ( mkUnqual, mkQual )
+import RdrName ( rdrNameOcc, setRdrNameOcc )
import RdrHsSyn ( RdrNameStmt )
-import OccName ( varName, dataName, tcClsName )
+import OccName ( dataName, tcClsName,
+ occNameSpace, setOccNameSpace )
import Type ( Type )
import Id ( Id, idName, setGlobalIdDetails )
import IdInfo ( GlobalIdDetails(VanillaGlobal) )
import PrelNames ( iNTERACTIVE )
import StringBuffer ( stringToStringBuffer )
import FastString ( mkFastString )
-import Char ( isUpper )
-import DriverUtil ( split_longest_prefix )
+import Maybes ( catMaybes )
#endif
import HsSyn
+import RdrName ( mkRdrOrig )
import Id ( idName )
import IdInfo ( CafInfo(..), CgInfoEnv, CgInfo(..) )
import StringBuffer ( hGetStringBuffer, freeStringBuffer )
import Rename ( checkOldIface, renameModule, closeIfaceDecls )
import Rules ( emptyRuleBase )
import PrelInfo ( wiredInThingEnv, wiredInThings )
+import PrelRules ( builtinRules )
import PrelNames ( knownKeyNames )
import MkIface ( mkFinalIface )
import TcModule
import Util ( unJust )
import UniqSupply ( mkSplitUniqSupply )
-import Bag ( emptyBag )
+import Bag ( consBag, emptyBag )
import Outputable
-import Interpreter
import HscStats ( ppSourceStats )
import HscTypes
import FiniteMap ( FiniteMap, plusFM, emptyFM, addToFM )
import IOExts ( newIORef, readIORef, writeIORef, unsafePerformIO )
import Monad ( when )
-import Maybe ( isJust, fromJust, catMaybes )
+import Maybe ( isJust, fromJust )
import IO
import MkExternalCore ( emitExternalCore )
mod location (Just old_iface) hst hit pcs_ch
| ghci_mode == OneShot
= do {
- hPutStrLn stderr "compilation IS NOT required";
+ when (verbosity dflags > 0) $
+ hPutStrLn stderr "compilation IS NOT required";
let { bomb = panic "hscNoRecomp:OneShot" };
return (HscNoRecomp pcs_ch bomb bomb)
}
\begin{code}
hscStmt dflags hst hit pcs0 icontext stmt just_expr
- = let
- InteractiveContext {
- ic_rn_env = rn_env,
- ic_type_env = type_env,
- ic_module = scope_mod } = icontext
- in
- do { maybe_stmt <- hscParseStmt dflags stmt
+ = do { maybe_stmt <- hscParseStmt dflags stmt
; case maybe_stmt of
Nothing -> return (pcs0, Nothing)
Just parsed_stmt -> do {
-- Rename it
(pcs1, print_unqual, maybe_renamed_stmt)
- <- renameStmt dflags hit hst pcs0 scope_mod
- iNTERACTIVE rn_env parsed_stmt
+ <- renameStmt dflags hit hst pcs0
+ iNTERACTIVE icontext parsed_stmt
; case maybe_renamed_stmt of
Nothing -> return (pcs0, Nothing)
maybe_tc_return <-
if just_expr
then case rn_stmt of { (ExprStmt e _ _, decls) ->
- typecheckExpr dflags pcs1 hst type_env
+ typecheckExpr dflags pcs1 hst (ic_type_env icontext)
print_unqual iNTERACTIVE (e,decls) }
- else typecheckStmt dflags pcs1 hst type_env
+ else typecheckStmt dflags pcs1 hst (ic_type_env icontext)
print_unqual iNTERACTIVE bound_names rn_stmt
; case maybe_tc_return of
[TyThing] )
hscThing dflags hst hit pcs0 icontext str
- = do let
- InteractiveContext {
- ic_rn_env = rn_env,
- ic_type_env = type_env,
- ic_module = scope_mod } = icontext
-
- rdr_names
- | '.' `elem` str
- = [ mkQual ns (fmod,fvar) | ns <- namespaces var ]
- | otherwise
- = [ mkUnqual ns fstr | ns <- namespaces str ]
- where (mod,var) = split_longest_prefix str '.'
- fmod = mkFastString mod
- fvar = mkFastString var
- fstr = mkFastString str
- namespaces s
- | isUpper c || c == ':' = [ tcClsName, dataName ]
- | otherwise = [ varName ]
- where c = head s
+ = do maybe_rdr_name <- myParseIdentifier dflags str
+ case maybe_rdr_name of {
+ Nothing -> return (pcs0, []);
+ Just rdr_name -> do
+
+ -- if the identifier is a constructor (begins with an
+ -- upper-case letter), then we need to consider both
+ -- constructor and type class identifiers.
+ let rdr_names
+ | occNameSpace occ == dataName = [ rdr_name, tccls_name ]
+ | otherwise = [ rdr_name ]
+ where
+ occ = rdrNameOcc rdr_name
+ tccls_occ = setOccNameSpace occ tcClsName
+ tccls_name = setRdrNameOcc rdr_name tccls_occ
(pcs, unqual, maybe_rn_result) <-
- renameRdrName dflags hit hst pcs0 scope_mod scope_mod
- rn_env rdr_names
+ renameRdrName dflags hit hst pcs0 iNTERACTIVE icontext rdr_names
case maybe_rn_result of {
Nothing -> return (pcs, []);
let maybe_ty_things = map (lookupType hst (pcs_PTE pcs)) names
in
return (pcs, catMaybes maybe_ty_things) }
- }}
+ }}}
+
+myParseIdentifier dflags str
+ = do buf <- stringToStringBuffer str
+
+ let glaexts | dopt Opt_GlasgowExts dflags = 1#
+ | otherwise = 0#
+
+ case parseIdentifier buf
+ PState{ bol = 0#, atbol = 1#,
+ context = [], glasgow_exts = glaexts,
+ loc = mkSrcLoc SLIT("<interactive>") 1 } of
+
+ PFailed err -> do { hPutStrLn stderr (showSDoc err);
+ freeStringBuffer buf;
+ return Nothing }
+
+ POk _ rdr_name -> do { --should, but can't: freeStringBuffer buf;
+ return (Just rdr_name) }
#endif
\end{code}
nsIPs = emptyFM },
prsDecls = (emptyNameEnv, 0),
prsInsts = (emptyBag, 0),
- prsRules = (emptyBag, 0),
+ prsRules = foldr add_rule (emptyBag, 0) builtinRules,
prsImpMods = emptyFM
}
)
+ where
+ add_rule (name,rule) (rules, n_rules)
+ = (gated_decl `consBag` rules, n_rules+1)
+ where
+ gated_decl = (gate_fn, (mod, IfaceRuleOut rdr_name rule))
+ mod = nameModule name
+ rdr_name = mkRdrOrig (moduleName mod) (nameOccName name)
+ gate_fn vis_fn = vis_fn name -- Load the rule whenever name is visible
initOrigNames :: FiniteMap (ModuleName,OccName) Name
initOrigNames
projects / ghc-hetmet.git / blobdiff