-\%
+%
% (c) The GRASP/AQUA Project, Glasgow University, 1992-2006
%
\section[RnEnv]{Environment manipulation for the renamer monad}
newTopSrcBinder, lookupFamInstDeclBndr,
lookupLocatedTopBndrRn, lookupTopBndrRn,
lookupLocatedOccRn, lookupOccRn,
- lookupLocatedGlobalOccRn, lookupGlobalOccRn,
- lookupLocalDataTcNames, lookupSrcOcc_maybe,
- lookupSigOccRn,
+ lookupLocatedGlobalOccRn,
+ lookupGlobalOccRn, lookupGlobalOccRn_maybe,
+ lookupLocalDataTcNames, lookupSigOccRn,
lookupFixityRn, lookupTyFixityRn,
lookupInstDeclBndr, lookupRecordBndr, lookupConstructorFields,
- lookupSyntaxName, lookupSyntaxTable, lookupImportedName,
+ lookupSyntaxName, lookupSyntaxTable,
lookupGreRn, lookupGreLocalRn, lookupGreRn_maybe,
getLookupOccRn,
mapFvRn, mapFvRnCPS,
warnUnusedMatches, warnUnusedModules, warnUnusedImports,
warnUnusedTopBinds, warnUnusedLocalBinds,
- dataTcOccs, unknownNameErr, perhapsForallMsg
+ dataTcOccs, unknownNameErr, kindSigErr, perhapsForallMsg,
+
+ checkM
) where
#include "HsVersions.h"
}
| otherwise -- Occurs in derived instances, where we just
- -- refer directly to the right method
- = ASSERT2( not (isQual rdr_name), ppr rdr_name )
- -- NB: qualified names are rejected by the parser
- lookupImportedName rdr_name
+ -- refer directly to the right method with an Orig
+ -- And record fields can be Quals: C { F.f = x }
+ = lookupGlobalOccRn rdr_name
newIPNameRn :: IPName RdrName -> TcRnIf m n (IPName Name)
newIPNameRn ip_rdr = newIPName (mapIPName rdrNameOcc ip_rdr)
lookupGlobalOccRn :: RdrName -> RnM Name
-- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
--- environment. It's used only for
--- record field names
--- class op names in class and instance decls
+-- environment. Adds an error message if the RdrName is not in scope.
+-- Also has a special case for GHCi.
lookupGlobalOccRn rdr_name
- | not (isSrcRdrName rdr_name)
- = lookupImportedName rdr_name
-
- | otherwise
- = do
- -- First look up the name in the normal environment.
- mb_gre <- lookupGreRn_maybe rdr_name
- case mb_gre of {
- Just gre -> returnM (gre_name gre) ;
- Nothing -> do
-
- -- We allow qualified names on the command line to refer to
- -- *any* name exported by any module in scope, just as if
- -- there was an "import qualified M" declaration for every
- -- module.
- allow_qual <- doptM Opt_ImplicitImportQualified
- mod <- getModule
+ = do { -- First look up the name in the normal environment.
+ mb_name <- lookupGlobalOccRn_maybe rdr_name
+ ; case mb_name of {
+ Just n -> return n ;
+ Nothing -> do
+
+ { -- We allow qualified names on the command line to refer to
+ -- *any* name exported by any module in scope, just as if there
+ -- was an "import qualified M" declaration for every module.
+ allow_qual <- doptM Opt_ImplicitImportQualified
+ ; mod <- getModule
-- This test is not expensive,
-- and only happens for failed lookups
- if isQual rdr_name && allow_qual && mod == iNTERACTIVE
- then lookupQualifiedName rdr_name
- else unboundName rdr_name
- }
-
-lookupImportedName :: RdrName -> TcRnIf m n Name
--- Lookup the occurrence of an imported name
--- The RdrName is *always* qualified or Exact
--- Treat it as an original name, and conjure up the Name
--- Usually it's Exact or Orig, but it can be Qual if it
--- comes from an hi-boot file. (This minor infelicity is
--- just to reduce duplication in the parser.)
-lookupImportedName rdr_name
- | Just n <- isExact_maybe rdr_name
- -- This happens in derived code
- = returnM n
-
- -- Always Orig, even when reading a .hi-boot file
+ ; if isQual rdr_name && allow_qual && mod == iNTERACTIVE
+ then lookupQualifiedName rdr_name
+ else unboundName rdr_name } } }
+
+lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
+-- No filter function; does not report an error on failure
+
+lookupGlobalOccRn_maybe rdr_name
+ | Just n <- isExact_maybe rdr_name -- This happens in derived code
+ = return (Just n)
+
| Just (rdr_mod, rdr_occ) <- isOrig_maybe rdr_name
- = lookupOrig rdr_mod rdr_occ
+ = do { n <- lookupOrig rdr_mod rdr_occ; return (Just n) }
| otherwise
- = pprPanic "RnEnv.lookupImportedName" (ppr rdr_name)
+ = do { mb_gre <- lookupGreRn_maybe rdr_name
+ ; case mb_gre of
+ Nothing -> return Nothing
+ Just gre -> return (Just (gre_name gre)) }
+
unboundName :: RdrName -> RnM Name
unboundName rdr_name
-- Lookup in the Global RdrEnv of the module
--------------------------------------------------
-lookupSrcOcc_maybe :: RdrName -> RnM (Maybe Name)
--- No filter function; does not report an error on failure
-lookupSrcOcc_maybe rdr_name
- = do { mb_gre <- lookupGreRn_maybe rdr_name
- ; case mb_gre of
- Nothing -> returnM Nothing
- Just gre -> returnM (Just (gre_name gre)) }
-
--------------------------
lookupGreRn_maybe :: RdrName -> RnM (Maybe GlobalRdrElt)
-- Just look up the RdrName in the GlobalRdrEnv
lookupGreRn_maybe rdr_name
-> 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
warnUnusedName :: (Name, Provenance) -> RnM ()
warnUnusedName (name, LocalDef)
- = addUnusedWarning name (srcLocSpan (nameSrcLoc name))
+ = addUnusedWarning name (nameSrcSpan name)
(ptext (sLit "Defined but not used"))
warnUnusedName (name, Imported is)
| 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