lookupInstDeclBndr, lookupRecordBndr, lookupConstructorFields,
lookupSyntaxName, lookupSyntaxTable,
lookupGreRn, lookupGreLocalRn, lookupGreRn_maybe,
- getLookupOccRn,
+ getLookupOccRn, addUsedRdrNames,
newLocalsRn, newIPNameRn,
bindLocalNames, bindLocalNamesFV,
mapFvRn, mapFvRnCPS,
warnUnusedMatches, warnUnusedModules, warnUnusedImports,
warnUnusedTopBinds, warnUnusedLocalBinds,
- dataTcOccs, unknownNameErr, perhapsForallMsg,
+ dataTcOccs, unknownNameErr, kindSigErr, perhapsForallMsg,
checkM
) where
import DynFlags
import FastString
import Control.Monad
+import qualified Data.Set as Set
\end{code}
\begin{code}
Looking up a name in the RnEnv.
+Note [Type and class operator definitions]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+We want to reject all of these unless we have -XTypeOperators (Trac #3265)
+ data a :*: b = ...
+ class a :*: b where ...
+ data (:*:) a b = ....
+ class (:*:) a b where ...
+The latter two mean that we are not just looking for a
+*syntactically-infix* declaration, but one that uses an operator
+OccName. We use OccName.isSymOcc to detect that case, which isn't
+terribly efficient, but there seems to be no better way.
+
\begin{code}
lookupTopBndrRn :: RdrName -> RnM Name
lookupTopBndrRn n = do nopt <- lookupTopBndrRn_maybe n
; return (Just n)}
| otherwise
- = do { mb_gre <- lookupGreLocalRn rdr_name
+ = do { -- Check for operators in type or class declarations
+ -- See Note [Type and class operator definitions]
+ let occ = rdrNameOcc rdr_name
+ ; when (isTcOcc occ && isSymOcc occ)
+ (do { op_ok <- doptM Opt_TypeOperators
+ ; checkM op_ok (addErr (opDeclErr rdr_name)) })
+
+ ; mb_gre <- lookupGreLocalRn rdr_name
; case mb_gre of
Nothing -> returnM Nothing
Just gre -> returnM (Just $ gre_name gre) }
lookup_sub_bndr is_good doc rdr_name
| isUnqual rdr_name -- Find all the things the rdr-name maps to
= do { -- and pick the one with the right parent name
+ ; addUsedRdrName rdr_name
; env <- getGlobalRdrEnv
; case filter is_good (lookupGlobalRdrEnv env (rdrNameOcc rdr_name)) of
-- NB: lookupGlobalRdrEnv, not lookupGRE_RdrName!
newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
--- Looking up family names in type instances is a subtle affair. The family
--- may be imported, in which case we need to lookup the occurence of a global
--- name. Alternatively, the family may be in the same binding group (and in
--- fact in a declaration processed later), and we need to create a new top
--- source binder.
---
--- So, also this is strictly speaking an occurence, we cannot raise an error
--- message yet for instances without a family declaration. This will happen
--- during renaming the type instance declaration in RnSource.rnTyClDecl.
+-- If the family is declared locally, it will not yet be in the main
+-- environment; hence, we pass in an extra one here, which we check first.
+-- See "Note [Looking up family names in family instances]" in 'RnNames'.
--
-lookupFamInstDeclBndr :: Module -> Located RdrName -> RnM Name
-lookupFamInstDeclBndr mod lrdr_name@(L _ rdr_name)
- = do { mb_gre <- lookupGreRn_maybe rdr_name
- ; case mb_gre of
- Just gre -> returnM (gre_name gre)
- Nothing -> newTopSrcBinder mod lrdr_name }
+lookupFamInstDeclBndr :: GlobalRdrEnv -> Located RdrName -> RnM Name
+lookupFamInstDeclBndr tyclGroupEnv (L loc rdr_name)
+ = setSrcSpan loc $
+ case lookupGRE_RdrName rdr_name tyclGroupEnv of
+ (gre:_) -> return $ gre_name gre
+ -- if there is more than one, an error will be raised elsewhere
+ [] -> lookupOccRn rdr_name
+
--------------------------------------------------
-- Occurrences
lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
-- Just look up the RdrName in the GlobalRdrEnv
lookupGreRn_maybe rdr_name
- = lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
+ = do { mGre <- lookupGreRn_help rdr_name (lookupGRE_RdrName rdr_name)
+ ; case mGre of
+ Just gre ->
+ case gre_prov gre of
+ LocalDef -> return ()
+ Imported _ -> addUsedRdrName rdr_name
+ Nothing ->
+ return ()
+ ; return mGre }
+
+addUsedRdrName :: RdrName -> RnM ()
+addUsedRdrName rdr
+ = do { env <- getGblEnv
+ ; updMutVar (tcg_used_rdrnames env)
+ (\s -> Set.insert rdr s) }
+
+addUsedRdrNames :: [RdrName] -> RnM ()
+addUsedRdrNames rdrs
+ = do { env <- getGblEnv
+ ; updMutVar (tcg_used_rdrnames env)
+ (\s -> foldr Set.insert s rdrs) }
lookupGreRn :: RdrName -> RnM GlobalRdrElt
-- If not found, add error message, and return a fake GRE
-> RnM a
-- Haskell-98 binding of type variables; e.g. within a data type decl
bindTyVarsRn doc_str tyvar_names enclosed_scope
- = let
- located_tyvars = hsLTyVarLocNames tyvar_names
- in
- bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
- enclosed_scope (zipWith replace tyvar_names names)
- where
- replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
+ = bindLocatedLocalsRn doc_str located_tyvars $ \ names ->
+ do { kind_sigs_ok <- doptM Opt_KindSignatures
+ ; checkM (null kinded_tyvars || kind_sigs_ok)
+ (mapM_ (addErr . kindSigErr) kinded_tyvars)
+ ; enclosed_scope (zipWith replace tyvar_names names) }
+ where
+ replace (L loc n1) n2 = L loc (replaceTyVarName n1 n2)
+ located_tyvars = hsLTyVarLocNames tyvar_names
+ kinded_tyvars = [n | L _ (KindedTyVar n _) <- tyvar_names]
bindPatSigTyVars :: [LHsType RdrName] -> ([Name] -> RnM a) -> RnM a
-- Find the type variables in the pattern type
; mappM_ check_shadow loc_rdr_names }
where
check_shadow (loc, occ)
+ | startsWithUnderscore occ = return () -- Do not report shadowing for "_x"
+ -- See Trac #3262
| Just n <- mb_local = complain [ptext (sLit "bound at") <+> ppr (nameSrcLoc n)]
| otherwise = do { gres' <- filterM is_shadowed_gre gres
; complain (map pprNameProvenance gres') }
| isWiredInName name = False -- Don't report unused wired-in names
-- Otherwise we get a zillion warnings
-- from Data.Tuple
- | otherwise = reportIfUnused (nameOccName name)
+ | otherwise = not (startsWithUnderscore (nameOccName name))
-------------------------
| otherwise = ptext (sLit "Bound at:") <+>
vcat (map ppr (sortLe (<=) locs))
+kindSigErr :: Outputable a => a -> SDoc
+kindSigErr thing
+ = hang (ptext (sLit "Illegal kind signature for") <+> quotes (ppr thing))
+ 2 (ptext (sLit "Perhaps you intended to use -XKindSignatures"))
+
+
badQualBndrErr :: RdrName -> SDoc
badQualBndrErr rdr_name
= ptext (sLit "Qualified name in binding position:") <+> ppr rdr_name
+
+opDeclErr :: RdrName -> SDoc
+opDeclErr n
+ = hang (ptext (sLit "Illegal declaration of a type or class operator") <+> quotes (ppr n))
+ 2 (ptext (sLit "Use -XTypeOperators to declare operators in type and declarations"))
\end{code}
projects / ghc-hetmet.git / blobdiff