+
+ -- REPORT UNUSED NAMES, AND DEBUG DUMP
+ reportUnusedNames mod_name direct_import_mods
+ gbl_env global_avail_env
+ export_avails source_fvs
+ rn_imp_decls `thenRn_`
+
+ returnRn (Just mod_iface, dump_action) }
+ where
+ trashed_exports = {-trace "rnSource:trashed_exports"-} Nothing
+ trashed_imports = {-trace "rnSource:trashed_imports"-} []
+\end{code}
+
+@implicitFVs@ forces the renamer to slurp in some things which aren't
+mentioned explicitly, but which might be needed by the type checker.
+
+\begin{code}
+implicitFVs mod_name decls
+ = lookupOrigNames implicit_occs `thenRn` \ implicit_names ->
+ returnRn (mkNameSet (map getName default_tycons) `plusFV`
+ implicit_names)
+ where
+ -- Add occurrences for Int, and (), because they
+ -- are the types to which ambigious type variables may be defaulted by
+ -- the type checker; so they won't always appear explicitly.
+ -- [The () one is a GHC extension for defaulting CCall results.]
+ -- ALSO: funTyCon, since it occurs implicitly everywhere!
+ -- (we don't want to be bothered with making funTyCon a
+ -- free var at every function application!)
+ -- Double is dealt with separately in getGates
+ default_tycons = [unitTyCon, funTyCon, boolTyCon, intTyCon]
+
+ -- Add occurrences for IO or PrimIO
+ implicit_main | mod_name == mAIN_Name
+ || mod_name == pREL_MAIN_Name = [ioTyCon_RDR]
+ | otherwise = []
+
+ -- Now add extra "occurrences" for things that
+ -- the deriving mechanism, or defaulting, will later need in order to
+ -- generate code
+ implicit_occs = string_occs ++ foldr ((++) . get) implicit_main decls
+
+ -- Virtually every program has error messages in it somewhere
+ string_occs = [unpackCString_RDR, unpackCStringFoldr_RDR, unpackCStringUtf8_RDR,
+ eqString_RDR]
+
+ get (TyClD (TyData _ _ _ _ _ _ (Just deriv_classes) _ _ _ _))
+ = concat (map get_deriv deriv_classes)
+ get other = []
+
+ get_deriv cls = case lookupUFM derivingOccurrences cls of
+ Nothing -> []
+ Just occs -> occs
+\end{code}
+
+\begin{code}
+isOrphanDecl (InstD (InstDecl inst_ty _ _ _ _))
+ = not (foldNameSet ((||) . isLocallyDefined) False (extractHsTyNames (removeContext inst_ty)))
+ -- The 'removeContext' is because of
+ -- instance Foo a => Baz T where ...
+ -- The decl is an orphan if Baz and T are both not locally defined,
+ -- even if Foo *is* locally defined
+
+isOrphanDecl (RuleD (HsRule _ _ _ lhs _ _))
+ = check lhs
+ where
+ -- At the moment we just check for common LHS forms
+ -- Expand as necessary. Getting it wrong just means
+ -- more orphans than necessary
+ check (HsVar v) = not (isLocallyDefined v)
+ check (HsApp f a) = check f && check a
+ check (HsLit _) = False
+ check (HsOverLit _) = False
+ check (OpApp l o _ r) = check l && check o && check r
+ check (NegApp e _) = check e
+ check (HsPar e) = check e
+ check (SectionL e o) = check e && check o
+ check (SectionR o e) = check e && check o
+
+ check other = True -- Safe fall through
+
+isOrphanDecl other = False
+\end{code}
+
+
+\begin{code}
+dupDefaultDeclErrRn (DefaultDecl _ locn1 : dup_things)
+ = pushSrcLocRn locn1 $
+ addErrRn msg
+ where
+ msg = hang (ptext SLIT("Multiple default declarations"))
+ 4 (vcat (map pp dup_things))
+ pp (DefaultDecl _ locn) = ptext SLIT("here was another default declaration") <+> ppr locn
+\end{code}
+
+
+%*********************************************************
+%* *
+\subsection{Slurping declarations}
+%* *
+%*********************************************************
+
+\begin{code}
+-------------------------------------------------------
+slurpImpDecls source_fvs
+ = traceRn (text "slurpImp" <+> fsep (map ppr (nameSetToList source_fvs))) `thenRn_`
+
+ -- The current slurped-set records all local things
+ getSlurped `thenRn` \ source_binders ->
+ slurpSourceRefs source_binders source_fvs `thenRn` \ (decls, needed) ->
+
+ -- Then get everything else
+ closeDecls decls needed `thenRn` \ decls1 ->
+
+ -- Finally, get any deferred data type decls
+ slurpDeferredDecls decls1 `thenRn` \ final_decls ->
+
+ returnRn final_decls
+
+-------------------------------------------------------
+slurpSourceRefs :: NameSet -- Variables defined in source
+ -> FreeVars -- Variables referenced in source
+ -> RnMG ([RenamedHsDecl],
+ FreeVars) -- Un-satisfied needs
+-- The declaration (and hence home module) of each gate has
+-- already been loaded
+
+slurpSourceRefs source_binders source_fvs
+ = go_outer [] -- Accumulating decls
+ emptyFVs -- Unsatisfied needs
+ emptyFVs -- Accumulating gates
+ (nameSetToList source_fvs) -- Things whose defn hasn't been loaded yet
+ where
+ -- The outer loop repeatedly slurps the decls for the current gates
+ -- and the instance decls
+
+ -- The outer loop is needed because consider
+ -- instance Foo a => Baz (Maybe a) where ...
+ -- It may be that @Baz@ and @Maybe@ are used in the source module,
+ -- but not @Foo@; so we need to chase @Foo@ too.
+ --
+ -- We also need to follow superclass refs. In particular, 'chasing @Foo@' must
+ -- include actually getting in Foo's class decl
+ -- class Wib a => Foo a where ..
+ -- so that its superclasses are discovered. The point is that Wib is a gate too.
+ -- We do this for tycons too, so that we look through type synonyms.
+
+ go_outer decls fvs all_gates []
+ = returnRn (decls, fvs)
+
+ go_outer decls fvs all_gates refs -- refs are not necessarily slurped yet
+ = traceRn (text "go_outer" <+> ppr refs) `thenRn_`
+ foldlRn go_inner (decls, fvs, emptyFVs) refs `thenRn` \ (decls1, fvs1, gates1) ->
+ getImportedInstDecls (all_gates `plusFV` gates1) `thenRn` \ inst_decls ->
+ rnInstDecls decls1 fvs1 gates1 inst_decls `thenRn` \ (decls2, fvs2, gates2) ->
+ go_outer decls2 fvs2 (all_gates `plusFV` gates2)
+ (nameSetToList (gates2 `minusNameSet` all_gates))
+ -- Knock out the all_gates because even if we don't slurp any new
+ -- decls we can get some apparently-new gates from wired-in names
+
+ go_inner (decls, fvs, gates) wanted_name
+ = importDecl wanted_name `thenRn` \ import_result ->
+ case import_result of
+ AlreadySlurped -> returnRn (decls, fvs, gates)
+ WiredIn -> returnRn (decls, fvs, gates `plusFV` getWiredInGates wanted_name)
+ Deferred -> returnRn (decls, fvs, gates `addOneFV` wanted_name) -- It's a type constructor
+
+ HereItIs decl -> rnIfaceDecl decl `thenRn` \ (new_decl, fvs1) ->
+ returnRn (new_decl : decls,
+ fvs1 `plusFV` fvs,
+ gates `plusFV` getGates source_fvs new_decl)
+
+rnInstDecls decls fvs gates []
+ = returnRn (decls, fvs, gates)
+rnInstDecls decls fvs gates (d:ds)
+ = rnIfaceDecl d `thenRn` \ (new_decl, fvs1) ->
+ rnInstDecls (new_decl:decls)
+ (fvs1 `plusFV` fvs)
+ (gates `plusFV` getInstDeclGates new_decl)
+ ds
+\end{code}
+
+
+\begin{code}
+-------------------------------------------------------
+-- closeDecls keeps going until the free-var set is empty
+closeDecls decls needed
+ | not (isEmptyFVs needed)
+ = slurpDecls decls needed `thenRn` \ (decls1, needed1) ->
+ closeDecls decls1 needed1
+
+ | otherwise
+ = getImportedRules `thenRn` \ rule_decls ->
+ case rule_decls of
+ [] -> returnRn decls -- No new rules, so we are done
+ other -> rnIfaceDecls decls emptyFVs rule_decls `thenRn` \ (decls1, needed1) ->
+ closeDecls decls1 needed1
+
+
+-------------------------------------------------------
+-- Augment decls with any decls needed by needed.
+-- Return also free vars of the new decls (only)
+slurpDecls decls needed
+ = go decls emptyFVs (nameSetToList needed)
+ where
+ go decls fvs [] = returnRn (decls, fvs)
+ go decls fvs (ref:refs) = slurpDecl decls fvs ref `thenRn` \ (decls1, fvs1) ->
+ go decls1 fvs1 refs
+
+-------------------------------------------------------
+slurpDecl decls fvs wanted_name
+ = importDecl wanted_name `thenRn` \ import_result ->
+ case import_result of
+ -- Found a declaration... rename it
+ HereItIs decl -> rnIfaceDecl decl `thenRn` \ (new_decl, fvs1) ->
+ returnRn (new_decl:decls, fvs1 `plusFV` fvs)
+
+ -- No declaration... (wired in thing, or deferred, or already slurped)
+ other -> returnRn (decls, fvs)
+
+
+-------------------------------------------------------
+rnIfaceDecls :: [RenamedHsDecl] -> FreeVars
+ -> [(Module, RdrNameHsDecl)]
+ -> RnM d ([RenamedHsDecl], FreeVars)
+rnIfaceDecls decls fvs [] = returnRn (decls, fvs)
+rnIfaceDecls decls fvs (d:ds) = rnIfaceDecl d `thenRn` \ (new_decl, fvs1) ->
+ rnIfaceDecls (new_decl:decls) (fvs1 `plusFV` fvs) ds
+
+rnIfaceDecl (mod, decl) = initIfaceRnMS mod (rnDecl decl)
+\end{code}
+
+
+%*********************************************************
+%* *
+\subsection{Deferred declarations}
+%* *
+%*********************************************************
+
+The idea of deferred declarations is this. Suppose we have a function
+ f :: T -> Int
+ data T = T1 A | T2 B
+ data A = A1 X | A2 Y
+ data B = B1 P | B2 Q
+Then we don't want to load T and all its constructors, and all
+the types those constructors refer to, and all the types *those*
+constructors refer to, and so on. That might mean loading many more
+interface files than is really necessary. So we 'defer' loading T.
+
+But f might be strict, and the calling convention for evaluating
+values of type T depends on how many constructors T has, so
+we do need to load T, but not the full details of the type T.
+So we load the full decl for T, but only skeleton decls for A and B:
+ f :: T -> Int
+ data T = {- 2 constructors -}
+
+Whether all this is worth it is moot.
+
+\begin{code}
+slurpDeferredDecls :: [RenamedHsDecl] -> RnMG [RenamedHsDecl]
+slurpDeferredDecls decls = returnRn decls
+
+{- OMIT FOR NOW
+slurpDeferredDecls :: [RenamedHsDecl] -> RnMG [RenamedHsDecl]
+slurpDeferredDecls decls
+ = getDeferredDecls `thenRn` \ def_decls ->
+ rnIfaceDecls decls emptyFVs (map stripDecl def_decls) `thenRn` \ (decls1, fvs) ->
+ ASSERT( isEmptyFVs fvs )
+ returnRn decls1
+
+stripDecl (mod, TyClD (TyData dt _ tc tvs _ nconstrs _ _ loc name1 name2))
+ = (mod, TyClD (TyData dt [] tc tvs [] nconstrs Nothing NoDataPragmas loc
+ name1 name2))
+ -- Nuke the context and constructors
+ -- But retain the *number* of constructors!
+ -- Also the tvs will have kinds on them.
+-}
+\end{code}
+
+
+%*********************************************************
+%* *
+\subsection{Extracting the `gates'}
+%* *
+%*********************************************************
+
+When we import a declaration like
+\begin{verbatim}
+ data T = T1 Wibble | T2 Wobble
+\end{verbatim}
+we don't want to treat @Wibble@ and @Wobble@ as gates
+{\em unless} @T1@, @T2@ respectively are mentioned by the user program.
+If only @T@ is mentioned
+we want only @T@ to be a gate;
+that way we don't suck in useless instance
+decls for (say) @Eq Wibble@, when they can't possibly be useful.
+
+@getGates@ takes a newly imported (and renamed) decl, and the free
+vars of the source program, and extracts from the decl the gate names.
+
+\begin{code}
+getGates source_fvs (SigD (IfaceSig _ ty _ _))
+ = extractHsTyNames ty
+
+getGates source_fvs (TyClD (ClassDecl ctxt cls tvs _ sigs _ _ _ _ ))
+ = (delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) sigs)
+ (hsTyVarNames tvs)
+ `addOneToNameSet` cls)
+ `plusFV` maybe_double
+ where
+ get (ClassOpSig n _ ty _)
+ | n `elemNameSet` source_fvs = extractHsTyNames ty
+ | otherwise = emptyFVs
+
+ -- If we load any numeric class that doesn't have
+ -- Int as an instance, add Double to the gates.
+ -- This takes account of the fact that Double might be needed for
+ -- defaulting, but we don't want to load Double (and all its baggage)
+ -- if the more exotic classes aren't used at all.
+ maybe_double | nameUnique cls `elem` fractionalClassKeys
+ = unitFV (getName doubleTyCon)
+ | otherwise
+ = emptyFVs
+
+getGates source_fvs (TyClD (TySynonym tycon tvs ty _))
+ = delListFromNameSet (extractHsTyNames ty)
+ (hsTyVarNames tvs)
+ -- A type synonym type constructor isn't a "gate" for instance decls
+
+getGates source_fvs (TyClD (TyData _ ctxt tycon tvs cons _ _ _ _ _ _))
+ = delListFromNameSet (foldr (plusFV . get) (extractHsCtxtTyNames ctxt) cons)
+ (hsTyVarNames tvs)
+ `addOneToNameSet` tycon
+ where
+ get (ConDecl n _ tvs ctxt details _)
+ | n `elemNameSet` source_fvs
+ -- If the constructor is method, get fvs from all its fields
+ = delListFromNameSet (get_details details `plusFV`
+ extractHsCtxtTyNames ctxt)
+ (hsTyVarNames tvs)
+ get (ConDecl n _ tvs ctxt (RecCon fields) _)
+ -- Even if the constructor isn't mentioned, the fields
+ -- might be, as selectors. They can't mention existentially
+ -- bound tyvars (typechecker checks for that) so no need for
+ -- the deleteListFromNameSet part
+ = foldr (plusFV . get_field) emptyFVs fields
+
+ get other_con = emptyFVs
+
+ get_details (VanillaCon tys) = plusFVs (map get_bang tys)
+ get_details (InfixCon t1 t2) = get_bang t1 `plusFV` get_bang t2
+ get_details (RecCon fields) = plusFVs [get_bang t | (_, t) <- fields]
+
+ get_field (fs,t) | any (`elemNameSet` source_fvs) fs = get_bang t
+ | otherwise = emptyFVs
+
+ get_bang bty = extractHsTyNames (getBangType bty)
+
+getGates source_fvs other_decl = emptyFVs
+\end{code}
+
+@getWiredInGates@ is just like @getGates@, but it sees a wired-in @Name@
+rather than a declaration.
+
+\begin{code}
+getWiredInGates :: Name -> FreeVars
+getWiredInGates name -- No classes are wired in
+ = case lookupNameEnv wiredInThingEnv name of
+ Just (AnId the_id) -> getWiredInGates_s (namesOfType (idType the_id))
+
+ Just (ATyCon tc)
+ | isSynTyCon tc
+ -> getWiredInGates_s (delListFromNameSet (namesOfType ty) (map getName tyvars))
+ where
+ (tyvars,ty) = getSynTyConDefn tc
+
+ other -> unitFV name
+
+getWiredInGates_s names = foldr (plusFV . getWiredInGates) emptyFVs (nameSetToList names)
+\end{code}
+
+\begin{code}
+getInstDeclGates (InstD (InstDecl inst_ty _ _ _ _)) = extractHsTyNames inst_ty
+getInstDeclGates other = emptyFVs
+\end{code}
+
+
+%*********************************************************
+%* *
+\subsection{Fixities}
+%* *
+%*********************************************************
+
+\begin{code}
+fixitiesFromLocalDecls :: GlobalRdrEnv -> [RdrNameHsDecl] -> RnMG LocalFixityEnv
+fixitiesFromLocalDecls gbl_env decls
+ = doptRn Opt_WarnUnusedBinds `thenRn` \ warn_unused ->
+ foldlRn (getFixities warn_unused) emptyNameEnv decls `thenRn` \ env ->
+ traceRn (text "fixity env" <+> vcat (map ppr (nameEnvElts env)))
+ `thenRn_`
+ returnRn env
+ where
+ getFixities :: Bool -> LocalFixityEnv -> RdrNameHsDecl -> RnMG LocalFixityEnv
+ getFixities warn_uu acc (FixD fix)
+ = fix_decl warn_uu acc fix
+
+ getFixities warn_uu acc (TyClD (ClassDecl _ _ _ _ sigs _ _ _ _ ))
+ = foldlRn (fix_decl warn_uu) acc [sig | FixSig sig <- sigs]
+ -- Get fixities from class decl sigs too.
+ getFixities warn_uu acc other_decl
+ = returnRn acc
+
+ fix_decl warn_uu acc sig@(FixitySig rdr_name fixity loc)
+ = -- Check for fixity decl for something not declared
+ case lookupRdrEnv gbl_env rdr_name of {
+ Nothing | warn_uu
+ -> pushSrcLocRn loc (addWarnRn (unusedFixityDecl rdr_name fixity))
+ `thenRn_` returnRn acc
+ | otherwise -> returnRn acc ;
+
+ Just ((name,_):_) ->
+
+ -- Check for duplicate fixity decl
+ case lookupNameEnv acc name of {
+ Just (FixitySig _ _ loc') -> addErrRn (dupFixityDecl rdr_name loc loc')
+ `thenRn_` returnRn acc ;
+
+ Nothing -> returnRn (extendNameEnv acc name (FixitySig name fixity loc))
+ }}
+\end{code}
+
+
+%*********************************************************
+%* *
+\subsection{Deprecations}
+%* *
+%*********************************************************
+
+For deprecations, all we do is check that the names are in scope.
+It's only imported deprecations, dealt with in RnIfaces, that we
+gather them together.
+
+\begin{code}
+rnDeprecs :: GlobalRdrEnv -> Maybe DeprecTxt
+ -> [RdrNameHsDecl] -> RnMG [RdrNameDeprecation]
+rnDeprecs gbl_env mod_deprec decls
+ = mapRn rn_deprec deprecs `thenRn_`
+ returnRn (extra_deprec ++ deprecs)
+ where
+ deprecs = [d | DeprecD d <- decls]
+ extra_deprec = case mod_deprec of
+ Nothing -> []
+ Just txt -> [Deprecation (IEModuleContents undefined) txt noSrcLoc]
+
+ rn_deprec (Deprecation ie txt loc)
+ = pushSrcLocRn loc $
+ mapRn check (ieNames ie)
+
+ check n = case lookupRdrEnv gbl_env n of
+ Nothing -> addErrRn (unknownNameErr n)
+ Just _ -> returnRn ()
+\end{code}
+
+
+%*********************************************************
+%* *
+\subsection{Unused names}
+%* *
+%*********************************************************
+
+\begin{code}
+reportUnusedNames :: ModuleName -> [ModuleName]
+ -> GlobalRdrEnv -> AvailEnv
+ -> Avails -> NameSet -> [RenamedHsDecl]
+ -> RnMG ()
+reportUnusedNames mod_name direct_import_mods
+ gbl_env avail_env
+ export_avails mentioned_names
+ imported_decls
+ = warnUnusedModules unused_imp_mods `thenRn_`
+ warnUnusedLocalBinds bad_locals `thenRn_`
+ warnUnusedImports bad_imp_names `thenRn_`
+ printMinimalImports mod_name minimal_imports `thenRn_`
+ warnDeprecations really_used_names `thenRn_`
+ returnRn ()
+
+ where
+ used_names = mentioned_names `unionNameSets` availsToNameSet export_avails
+
+ -- Now, a use of C implies a use of T,
+ -- if C was brought into scope by T(..) or T(C)
+ really_used_names = used_names `unionNameSets`
+ mkNameSet [ parent_name
+ | sub_name <- nameSetToList used_names