import DynFlags
import HsSyn
+import TcEnv ( isBrackStage )
import RnEnv
import RnHsDoc ( rnHsDoc )
import IfaceEnv ( ifaceExportNames )
-- Issue a user warning for a redundant {- SOURCE -} import
-- NB that we arrange to read all the ordinary imports before
- -- any of the {- SOURCE -} imports
- warnIf (want_boot && not (mi_boot iface))
+ -- any of the {- SOURCE -} imports.
+ --
+ -- in --make and GHCi, the compilation manager checks for this,
+ -- and indeed we shouldn't do it here because the existence of
+ -- the non-boot module depends on the compilation order, which
+ -- is not deterministic. The hs-boot test can show this up.
+ dflags <- getDOpts
+ warnIf (want_boot && not (mi_boot iface) && isOneShot (ghcMode dflags))
(warnRedundantSourceImport imp_mod_name)
let
* the ImportAvails
created by its bindings.
-Note [Shadowing in extendGlobalRdrEnvRn]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Usually when etending the GlobalRdrEnv we complain if a new binding
-duplicates an existing one. By adding the bindings one at a time,
-this check also complains if we add two new bindings for the same name.
-(Remember that in Template Haskell the duplicates might *already be*
-in the GlobalRdrEnv from higher up the module.)
-
-But with a Template Haskell quotation we want to *shadow*:
+Note [Top-level Names in Template Haskell decl quotes]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Consider a Template Haskell declaration quotation like this:
+ module M where
f x = h [d| f = 3 |]
-Here the inner binding for 'f' simply shadows the outer one.
-And that applies even if the binding for 'f' is in a where-clause,
-and hence is in the *local* RdrEnv not the *global* RdrEnv.
+When renaming the declarations inside [d| ...|], we treat the
+top level binders specially in two ways
+
+1. We give them an Internal name, not (as usual) an External one.
+ Otherwise the NameCache gets confused by a second allocation of
+ M.f. (We used to invent a fake module ThFake to avoid this, but
+ that had other problems, notably in getting the correct answer for
+ nameIsLocalOrFrom in lookupFixity. So we now leave tcg_module
+ unaffected.)
+
+2. We make them *shadow* the outer bindings. If we don't do that,
+ we'll get a complaint when extending the GlobalRdrEnv, saying that
+ there are two bindings for 'f'.
-Hence the shadowP boolean passed in.
+ This shadowing applies even if the binding for 'f' is in a
+ where-clause, and hence is in the *local* RdrEnv not the *global*
+ RdrEnv.
+
+We find out whether we are inside a [d| ... |] by testing the TH
+stage. This is a slight hack, because the stage field was really meant for
+the type checker, and here we are not interested in the fields of Brack,
+hence the error thunks in thRnBrack.
\begin{code}
-extendGlobalRdrEnvRn :: Bool -- Note [Shadowing in extendGlobalRdrEnvRn]
- -> [AvailInfo]
+extendGlobalRdrEnvRn :: [AvailInfo]
-> MiniFixityEnv
-> RnM (TcGblEnv, TcLclEnv)
-- Updates both the GlobalRdrEnv and the FixityEnv
-- We return a new TcLclEnv only becuase we might have to
- -- delete some bindings from it; see Note [Shadowing in extendGlobalRdrEnvRn]
+ -- delete some bindings from it;
+ -- see Note [Top-level Names in Template Haskell decl quotes]
-extendGlobalRdrEnvRn shadowP avails new_fixities
+extendGlobalRdrEnvRn avails new_fixities
= do { (gbl_env, lcl_env) <- getEnvs
+ ; stage <- getStage
; let rdr_env = tcg_rdr_env gbl_env
fix_env = tcg_fix_env gbl_env
-- Delete new_occs from global and local envs
- -- We are going to shadow them
- -- See Note [Shadowing in extendGlobalRdrEnvRn]
+ -- If we are in a TemplateHaskell decl bracket,
+ -- we are going to shadow them
+ -- See Note [Top-level Names in Template Haskell decl quotes]
+ shadowP = isBrackStage stage
new_occs = map (nameOccName . gre_name) gres
rdr_env1 = hideSomeUnquals rdr_env new_occs
lcl_env1 = lcl_env { tcl_rdr = delListFromOccEnv (tcl_rdr lcl_env) new_occs }
-
- -- Note [Shadowing in extendGlobalRdrEnvRn]
(rdr_env2, lcl_env2) | shadowP = (rdr_env1, lcl_env1)
| otherwise = (rdr_env, lcl_env)
Instances of type families
~~~~~~~~~~~~~~~~~~~~~~~~~~
-Indexed data/newtype instances contain data constructors that we need to
-collect, too. Moreover, we need to descend into the data/newtypes instances
-of associated families.
+Family instances contain data constructors that we need to collect and we also
+need to descend into the type instances of associated families in class
+instances. The type constructor of a family instance is a usage occurence.
+Hence, we don't return it as a subname in 'AvailInfo'; otherwise, we would get
+a duplicate declaration error.
+
+Note [Looking up family names in family instances]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Consider
+
+ module M where
+ type family T a :: *
+ type instance M.T Int = Bool
+
+We might think that we can simply use 'lookupOccRn' when processing the type
+instance to look up 'M.T'. Alas, we can't! The type family declaration is in
+the *same* HsGroup as the type instance declaration. Hence, as we are
+currently collecting the binders declared in that HsGroup, these binders will
+not have been added to the global environment yet.
+
+In the case of type classes, this problem does not arise, as a class instance
+does not define any binders of it's own. So, we simply don't attempt to look
+up the class names of class instances in 'get_local_binders' below.
+
+If we don't look up class instances, can't we get away without looking up type
+instances, too? No, we can't. Data type instances define data constructors
+and we need to
+
+ (1) collect those in 'get_local_binders' and
+ (2) we need to get their parent name in 'get_local_binders', too, to
+ produce an appropriate 'AvailTC'.
+
+This parent name is exactly the family name of the type instance that is so
+difficult to look up.
-We need to be careful with the handling of the type constructor of each type
-instance as the family constructor is already defined, and we want to avoid
-raising a duplicate declaration error. So, we make a new name for it, but
-don't return it in the 'AvailInfo'.
+We solve this problem as follows:
+
+ (a) We process all type declarations other than type instances first.
+ (b) Then, we compute a 'GlobalRdrEnv' from the result of the first step.
+ (c) Finally, we process all type instances (both those on the toplevel and
+ those nested in class instances) and check for the family names in the
+ 'GlobalRdrEnv' produced in the previous step before using 'lookupOccRn'.
\begin{code}
getLocalNonValBinders :: HsGroup RdrName -> RnM [AvailInfo]
hs_tyclds = tycl_decls,
hs_instds = inst_decls,
hs_fords = foreign_decls })
- = do { tc_names_s <- mapM new_tc tycl_decls
- ; at_names_s <- mapM inst_ats inst_decls
- ; val_names <- mapM new_simple val_bndrs
- ; return (val_names ++ tc_names_s ++ concat at_names_s) }
+ = do { -- separate out the family instance declarations
+ let (tyinst_decls1, tycl_decls_noinsts)
+ = partition (isFamInstDecl . unLoc) tycl_decls
+ tyinst_decls = tyinst_decls1 ++
+ concatMap (instDeclATs . unLoc) inst_decls
+
+ -- process all type/class decls except family instances
+ ; tc_names <- mapM new_tc tycl_decls_noinsts
+
+ -- create a temporary rdr env of the type binders
+ ; let tc_gres = gresFromAvails LocalDef tc_names
+ tc_name_env = foldl extendGlobalRdrEnv emptyGlobalRdrEnv tc_gres
+
+ -- process all family instances
+ ; ti_names <- mapM (new_ti tc_name_env) tyinst_decls
+
+ -- finish off with value binder in case of a hs-boot file
+ ; val_names <- mapM new_simple val_bndrs
+ ; return (val_names ++ tc_names ++ ti_names) }
where
mod = tcg_mod gbl_env
is_hs_boot = isHsBoot (tcg_src gbl_env) ;
nm <- newTopSrcBinder mod rdr_name
return (Avail nm)
- new_tc tc_decl
- | isFamInstDecl (unLoc tc_decl)
- = do { main_name <- lookupFamInstDeclBndr mod main_rdr
- ; sub_names <- mapM (newTopSrcBinder mod) sub_rdrs
- ; return (AvailTC main_name sub_names) }
- -- main_name is not bound here!
- | otherwise
+ new_tc tc_decl -- NOT for type/data instances
= do { main_name <- newTopSrcBinder mod main_rdr
; sub_names <- mapM (newTopSrcBinder mod) sub_rdrs
; return (AvailTC main_name (main_name : sub_names)) }
where
(main_rdr : sub_rdrs) = tyClDeclNames (unLoc tc_decl)
- inst_ats inst_decl
- = mapM new_tc (instDeclATs (unLoc inst_decl))
+ new_ti tc_name_env ti_decl -- ONLY for type/data instances
+ = do { main_name <- lookupFamInstDeclBndr tc_name_env main_rdr
+ ; sub_names <- mapM (newTopSrcBinder mod) sub_rdrs
+ ; return (AvailTC main_name sub_names) }
+ -- main_name is not bound here!
+ where
+ (main_rdr : sub_rdrs) = tyClDeclNames (unLoc ti_decl)
get_local_binders _ g = pprPanic "get_local_binders" (ppr g)
\end{code}
-- every module that imports the Prelude
| otherwise
= case prov of
- LocalDef -> moduleName (nameModule name) == mod
+ LocalDef | Just name_mod <- nameModule_maybe name
+ -> moduleName name_mod == mod
+ | otherwise -> False
Imported is -> any unQualSpecOK is && any (qualSpecOK mod) is
-------------------------------
dodgyMsg :: OutputableBndr n => SDoc -> n -> SDoc
dodgyMsg kind tc
- = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc)),
- ptext (sLit "suggests that") <+> quotes (ppr tc) <+> ptext (sLit "has constructors or class methods,"),
+ = sep [ ptext (sLit "The") <+> kind <+> ptext (sLit "item") <+> quotes (ppr (IEThingAll tc))
+ <+> ptext (sLit "suggests that"),
+ quotes (ppr tc) <+> ptext (sLit "has (in-scope) constructors or class methods,"),
ptext (sLit "but it has none") ]
exportItemErr :: IE RdrName -> SDoc
projects / ghc-hetmet.git / blobdiff