{-# LANGUAGE CPP #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE TypeApplications #-}

{-
(c) The GRASP/AQUA Project, Glasgow University, 1992-2006

GHC.Rename.Env contains functions which convert RdrNames into Names.

-}

module GHC.Rename.Env (
        newTopSrcBinder,

        lookupLocatedTopBndrRn, lookupLocatedTopBndrRnN, lookupTopBndrRn,

        lookupLocatedOccRn, lookupOccRn, lookupOccRn_maybe,
        lookupLocalOccRn_maybe, lookupInfoOccRn,
        lookupLocalOccThLvl_maybe, lookupLocalOccRn,
        lookupTypeOccRn,
        lookupGlobalOccRn, lookupGlobalOccRn_maybe,

        AmbiguousResult(..),
        lookupExprOccRn,
        lookupRecFieldOcc,
        lookupRecFieldOcc_update,

        ChildLookupResult(..),
        lookupSubBndrOcc_helper,
        combineChildLookupResult, -- Called by lookupChildrenExport

        HsSigCtxt(..), lookupLocalTcNames, lookupSigOccRn, lookupSigOccRnN,
        lookupSigCtxtOccRn, lookupSigCtxtOccRnN,

        lookupInstDeclBndr, lookupFamInstName,
        lookupConstructorFields,

        lookupGreAvailRn,

        -- Rebindable Syntax
        lookupSyntax, lookupSyntaxExpr, lookupSyntaxNames,
        lookupSyntaxName,
        lookupIfThenElse,

        -- QualifiedDo
        lookupQualifiedDoExpr, lookupQualifiedDo,
        lookupQualifiedDoName, lookupNameWithQualifier,

        -- Constructing usage information
        addUsedGRE, addUsedGREs, addUsedDataCons,



        dataTcOccs, --TODO: Move this somewhere, into utils?

    ) where

#include "HsVersions.h"

import GHC.Prelude

import GHC.Iface.Load   ( loadInterfaceForName, loadSrcInterface_maybe )
import GHC.Iface.Env
import GHC.Hs
import GHC.Types.Name.Reader
import GHC.Tc.Utils.Env
import GHC.Tc.Utils.Monad
import GHC.Parser.PostProcess ( setRdrNameSpace )
import GHC.Builtin.Types
import GHC.Types.Name
import GHC.Types.Name.Set
import GHC.Types.Name.Env
import GHC.Types.Avail
import GHC.Unit.Module
import GHC.Unit.Module.ModIface
import GHC.Unit.Module.Warnings  ( WarningTxt, pprWarningTxtForMsg )
import GHC.Core.ConLike
import GHC.Core.DataCon
import GHC.Core.TyCon
import GHC.Builtin.Names( rOOT_MAIN )
import GHC.Types.Basic  ( TopLevelFlag(..), TupleSort(..) )
import GHC.Types.SrcLoc as SrcLoc
import GHC.Utils.Outputable as Outputable
import GHC.Types.Unique.Set ( uniqSetAny )
import GHC.Utils.Misc
import GHC.Utils.Panic
import GHC.Data.Maybe
import GHC.Driver.Session
import GHC.Data.FastString
import Control.Monad
import GHC.Data.List.SetOps ( minusList )
import qualified GHC.LanguageExtensions as LangExt
import GHC.Rename.Unbound
import GHC.Rename.Utils
import qualified Data.Semigroup as Semi
import Data.Either      ( partitionEithers )
import Data.List        ( find, sortBy )
import qualified Data.List.NonEmpty as NE
import Control.Arrow    ( first )
import Data.Function
import GHC.Types.FieldLabel

{-
*********************************************************
*                                                      *
                Source-code binders
*                                                      *
*********************************************************

Note [Signature lazy interface loading]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

GHC's lazy interface loading can be a bit confusing, so this Note is an
empirical description of what happens in one interesting case. When
compiling a signature module against an its implementation, we do NOT
load interface files associated with its names until after the type
checking phase.  For example:

    module ASig where
        data T
        f :: T -> T

Suppose we compile this with -sig-of "A is ASig":

    module B where
        data T = T
        f T = T

    module A(module B) where
        import B

During type checking, we'll load A.hi because we need to know what the
RdrEnv for the module is, but we DO NOT load the interface for B.hi!
It's wholly unnecessary: our local definition 'data T' in ASig is all
the information we need to finish type checking.  This is contrast to
type checking of ordinary Haskell files, in which we would not have the
local definition "data T" and would need to consult B.hi immediately.
(Also, this situation never occurs for hs-boot files, since you're not
allowed to reexport from another module.)

After type checking, we then check that the types we provided are
consistent with the backing implementation (in checkHiBootOrHsigIface).
At this point, B.hi is loaded, because we need something to compare
against.

I discovered this behavior when trying to figure out why type class
instances for Data.Map weren't in the EPS when I was type checking a
test very much like ASig (sigof02dm): the associated interface hadn't
been loaded yet!  (The larger issue is a moot point, since an instance
declared in a signature can never be a duplicate.)

This behavior might change in the future.  Consider this
alternate module B:

    module B where
        {-# DEPRECATED T, f "Don't use" #-}
        data T = T
        f T = T

One might conceivably want to report deprecation warnings when compiling
ASig with -sig-of B, in which case we need to look at B.hi to find the
deprecation warnings during renaming.  At the moment, you don't get any
warning until you use the identifier further downstream.  This would
require adjusting addUsedGRE so that during signature compilation,
we do not report deprecation warnings for LocalDef.  See also
Note [Handling of deprecations]
-}

newTopSrcBinder :: LocatedN RdrName -> RnM Name
newTopSrcBinder :: LocatedN RdrName -> RnM Name
newTopSrcBinder (L SrcSpanAnnN
loc RdrName
rdr_name)
  | Just Name
name <- RdrName -> Maybe Name
isExact_maybe RdrName
rdr_name
  =     -- This is here to catch
        --   (a) Exact-name binders created by Template Haskell
        --   (b) The PrelBase defn of (say) [] and similar, for which
        --       the parser reads the special syntax and returns an Exact RdrName
        -- We are at a binding site for the name, so check first that it
        -- the current module is the correct one; otherwise GHC can get
        -- very confused indeed. This test rejects code like
        --      data T = (,) Int Int
        -- unless we are in GHC.Tup
    if Name -> Bool
isExternalName Name
name then
      do { Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
         ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Module
this_mod forall a. Eq a => a -> a -> Bool
== HasDebugCallStack => Name -> Module
nameModule Name
name)
                  (SrcSpan -> SDoc -> TcRn ()
addErrAt (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnN
loc) (RdrName -> SDoc
badOrigBinding RdrName
rdr_name))
         ; forall (m :: * -> *) a. Monad m => a -> m a
return Name
name }
    else   -- See Note [Binders in Template Haskell] in "GHC.ThToHs"
      do { Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
         ; forall m n. Module -> Name -> TcRnIf m n Name
externaliseName Module
this_mod Name
name }

  | Just (Module
rdr_mod, OccName
rdr_occ) <- RdrName -> Maybe (Module, OccName)
isOrig_maybe RdrName
rdr_name
  = do  { Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
        ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Module
rdr_mod forall a. Eq a => a -> a -> Bool
== Module
this_mod Bool -> Bool -> Bool
|| Module
rdr_mod forall a. Eq a => a -> a -> Bool
== Module
rOOT_MAIN)
                 (SrcSpan -> SDoc -> TcRn ()
addErrAt (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnN
loc) (RdrName -> SDoc
badOrigBinding RdrName
rdr_name))
        -- When reading External Core we get Orig names as binders,
        -- but they should agree with the module gotten from the monad
        --
        -- We can get built-in syntax showing up here too, sadly.  If you type
        --      data T = (,,,)
        -- the constructor is parsed as a type, and then GHC.Parser.PostProcess.tyConToDataCon
        -- uses setRdrNameSpace to make it into a data constructors.  At that point
        -- the nice Exact name for the TyCon gets swizzled to an Orig name.
        -- Hence the badOrigBinding error message.
        --
        -- Except for the ":Main.main = ..." definition inserted into
        -- the Main module; ugh!

        -- Because of this latter case, we call newGlobalBinder with a module from
        -- the RdrName, not from the environment.  In principle, it'd be fine to
        -- have an arbitrary mixture of external core definitions in a single module,
        -- (apart from module-initialisation issues, perhaps).
        ; forall a b. Module -> OccName -> SrcSpan -> TcRnIf a b Name
newGlobalBinder Module
rdr_mod OccName
rdr_occ (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnN
loc) }

  | Bool
otherwise
  = do  { forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (RdrName -> Bool
isQual RdrName
rdr_name)
                 (SrcSpan -> SDoc -> TcRn ()
addErrAt (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnN
loc) (RdrName -> SDoc
badQualBndrErr RdrName
rdr_name))
                -- Binders should not be qualified; if they are, and with a different
                -- module name, we get a confusing "M.T is not in scope" error later

        ; ThStage
stage <- TcM ThStage
getStage
        ; if ThStage -> Bool
isBrackStage ThStage
stage then
                -- We are inside a TH bracket, so make an *Internal* name
                -- See Note [Top-level Names in Template Haskell decl quotes] in GHC.Rename.Names
             do { Unique
uniq <- forall gbl lcl. TcRnIf gbl lcl Unique
newUnique
                ; forall (m :: * -> *) a. Monad m => a -> m a
return (Unique -> OccName -> SrcSpan -> Name
mkInternalName Unique
uniq (RdrName -> OccName
rdrNameOcc RdrName
rdr_name) (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnN
loc)) }
          else
             do { Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
                ; String -> SDoc -> TcRn ()
traceRn String
"newTopSrcBinder" (forall a. Outputable a => a -> SDoc
ppr Module
this_mod SDoc -> SDoc -> SDoc
$$ forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name SDoc -> SDoc -> SDoc
$$ forall a. Outputable a => a -> SDoc
ppr (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnN
loc))
                ; forall a b. Module -> OccName -> SrcSpan -> TcRnIf a b Name
newGlobalBinder Module
this_mod (RdrName -> OccName
rdrNameOcc RdrName
rdr_name) (forall a. SrcSpanAnn' a -> SrcSpan
locA SrcSpanAnnN
loc) }
        }

{-
*********************************************************
*                                                      *
        Source code occurrences
*                                                      *
*********************************************************

Looking up a name in the GHC.Rename.Env.

Note [Type and class operator definitions]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We want to reject all of these unless we have -XTypeOperators (#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.
-}

-- Can be made to not be exposed
-- Only used unwrapped in rnAnnProvenance
lookupTopBndrRn :: RdrName -> RnM Name
-- Look up a top-level source-code binder.   We may be looking up an unqualified 'f',
-- and there may be several imported 'f's too, which must not confuse us.
-- For example, this is OK:
--      import Foo( f )
--      infix 9 f       -- The 'f' here does not need to be qualified
--      f x = x         -- Nor here, of course
-- So we have to filter out the non-local ones.
--
-- A separate function (importsFromLocalDecls) reports duplicate top level
-- decls, so here it's safe just to choose an arbitrary one.
lookupTopBndrRn :: RdrName -> RnM Name
lookupTopBndrRn RdrName
rdr_name =
  forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
lookupExactOrOrig RdrName
rdr_name forall a. a -> a
id forall a b. (a -> b) -> a -> b
$
    do  {  -- Check for operators in type or class declarations
           -- See Note [Type and class operator definitions]
          let occ :: OccName
occ = RdrName -> OccName
rdrNameOcc RdrName
rdr_name
        ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (OccName -> Bool
isTcOcc OccName
occ Bool -> Bool -> Bool
&& OccName -> Bool
isSymOcc OccName
occ)
               (do { Bool
op_ok <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.TypeOperators
                   ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
op_ok (SDoc -> TcRn ()
addErr (RdrName -> SDoc
opDeclErr RdrName
rdr_name)) })

        ; GlobalRdrEnv
env <- TcRn GlobalRdrEnv
getGlobalRdrEnv
        ; case forall a. (a -> Bool) -> [a] -> [a]
filter GlobalRdrElt -> Bool
isLocalGRE (RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
lookupGRE_RdrName RdrName
rdr_name GlobalRdrEnv
env) of
            [GlobalRdrElt
gre] -> forall (m :: * -> *) a. Monad m => a -> m a
return (GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre)
            [GlobalRdrElt]
_     -> do -- Ambiguous (can't happen) or unbound
                        String -> SDoc -> TcRn ()
traceRn String
"lookupTopBndrRN fail" (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)
                        WhereLooking -> RdrName -> RnM Name
unboundName WhereLooking
WL_LocalTop RdrName
rdr_name
    }

lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn :: Located RdrName -> RnM (Located Name)
lookupLocatedTopBndrRn = forall a b. (a -> TcM b) -> Located a -> TcM (Located b)
wrapLocM RdrName -> RnM Name
lookupTopBndrRn

lookupLocatedTopBndrRnN :: LocatedN RdrName -> RnM (LocatedN Name)
lookupLocatedTopBndrRnN :: LocatedN RdrName -> RnM (LocatedN Name)
lookupLocatedTopBndrRnN = forall a b ann.
(a -> TcM b)
-> GenLocated (SrcSpanAnn' ann) a
-> TcRn (GenLocated (SrcSpanAnn' ann) b)
wrapLocMA RdrName -> RnM Name
lookupTopBndrRn

-- | Lookup an @Exact@ @RdrName@. See Note [Looking up Exact RdrNames].
-- This never adds an error, but it may return one, see
-- Note [Errors in lookup functions]
lookupExactOcc_either :: Name -> RnM (Either SDoc Name)
lookupExactOcc_either :: Name -> RnM (Either SDoc Name)
lookupExactOcc_either Name
name
  | Just TyThing
thing <- Name -> Maybe TyThing
wiredInNameTyThing_maybe Name
name
  , Just TyCon
tycon <- case TyThing
thing of
                    ATyCon TyCon
tc                 -> forall a. a -> Maybe a
Just TyCon
tc
                    AConLike (RealDataCon DataCon
dc) -> forall a. a -> Maybe a
Just (DataCon -> TyCon
dataConTyCon DataCon
dc)
                    TyThing
_                         -> forall a. Maybe a
Nothing
  , Just TupleSort
tupleSort <- TyCon -> Maybe TupleSort
tyConTuple_maybe TyCon
tycon
  = do { let tupArity :: Arity
tupArity = case TupleSort
tupleSort of
               -- Unboxed tuples have twice as many arguments because of the
               -- 'RuntimeRep's (#17837)
               TupleSort
UnboxedTuple -> TyCon -> Arity
tyConArity TyCon
tycon forall a. Integral a => a -> a -> a
`div` Arity
2
               TupleSort
_ -> TyCon -> Arity
tyConArity TyCon
tycon
       ; Arity -> TcRn ()
checkTupSize Arity
tupArity
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right Name
name) }

  | Name -> Bool
isExternalName Name
name
  = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right Name
name)

  | Bool
otherwise
  = do { GlobalRdrEnv
env <- TcRn GlobalRdrEnv
getGlobalRdrEnv
       ; let -- See Note [Splicing Exact names]
             main_occ :: OccName
main_occ =  Name -> OccName
nameOccName Name
name
             demoted_occs :: [OccName]
demoted_occs = case OccName -> Maybe OccName
demoteOccName OccName
main_occ of
                              Just OccName
occ -> [OccName
occ]
                              Maybe OccName
Nothing  -> []
             gres :: [GlobalRdrElt]
gres = [ GlobalRdrElt
gre | OccName
occ <- OccName
main_occ forall a. a -> [a] -> [a]
: [OccName]
demoted_occs
                          , GlobalRdrElt
gre <- GlobalRdrEnv -> OccName -> [GlobalRdrElt]
lookupGlobalRdrEnv GlobalRdrEnv
env OccName
occ
                          , GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre forall a. Eq a => a -> a -> Bool
== Name
name ]
       ; case [GlobalRdrElt]
gres of
           [GlobalRdrElt
gre] -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right (GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre))

           []    -> -- See Note [Splicing Exact names]
                    do { LocalRdrEnv
lcl_env <- RnM LocalRdrEnv
getLocalRdrEnv
                       ; if Name
name Name -> LocalRdrEnv -> Bool
`inLocalRdrEnvScope` LocalRdrEnv
lcl_env
                         then forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right Name
name)
                         else
                         do { TcRef NameSet
th_topnames_var <- forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TcGblEnv -> TcRef NameSet
tcg_th_topnames forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv
                            ; NameSet
th_topnames <- forall a gbl lcl. TcRef a -> TcRnIf gbl lcl a
readTcRef TcRef NameSet
th_topnames_var
                            ; if Name
name Name -> NameSet -> Bool
`elemNameSet` NameSet
th_topnames
                              then forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right Name
name)
                              else forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left (Name -> SDoc
exactNameErr Name
name))
                            }
                       }
           [GlobalRdrElt]
gres -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left ([GlobalRdrElt] -> SDoc
sameNameErr [GlobalRdrElt]
gres))   -- Ugh!  See Note [Template Haskell ambiguity]
       }

sameNameErr :: [GlobalRdrElt] -> SDoc
sameNameErr :: [GlobalRdrElt] -> SDoc
sameNameErr [] = forall a. String -> a
panic String
"addSameNameErr: empty list"
sameNameErr gres :: [GlobalRdrElt]
gres@(GlobalRdrElt
_ : [GlobalRdrElt]
_)
  = SDoc -> Arity -> SDoc -> SDoc
hang (String -> SDoc
text String
"Same exact name in multiple name-spaces:")
       Arity
2 ([SDoc] -> SDoc
vcat (forall a b. (a -> b) -> [a] -> [b]
map Name -> SDoc
pp_one [Name]
sorted_names) SDoc -> SDoc -> SDoc
$$ SDoc
th_hint)
  where
    sorted_names :: [Name]
sorted_names = forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (SrcSpan -> SrcSpan -> Ordering
SrcLoc.leftmost_smallest forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` Name -> SrcSpan
nameSrcSpan) (forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrElt -> Name
greMangledName [GlobalRdrElt]
gres)
    pp_one :: Name -> SDoc
pp_one Name
name
      = SDoc -> Arity -> SDoc -> SDoc
hang (NameSpace -> SDoc
pprNameSpace (OccName -> NameSpace
occNameSpace (forall a. NamedThing a => a -> OccName
getOccName Name
name))
              SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr Name
name) SDoc -> SDoc -> SDoc
<> SDoc
comma)
           Arity
2 (String -> SDoc
text String
"declared at:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr (Name -> SrcLoc
nameSrcLoc Name
name))

    th_hint :: SDoc
th_hint = [SDoc] -> SDoc
vcat [ String -> SDoc
text String
"Probable cause: you bound a unique Template Haskell name (NameU),"
                   , String -> SDoc
text String
"perhaps via newName, in different name-spaces."
                   , String -> SDoc
text String
"If that's it, then -ddump-splices might be useful" ]


-----------------------------------------------
lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
-- This is called on the method name on the left-hand side of an
-- instance declaration binding. eg.  instance Functor T where
--                                       fmap = ...
--                                       ^^^^ called on this
-- Regardless of how many unqualified fmaps are in scope, we want
-- the one that comes from the Functor class.
--
-- Furthermore, note that we take no account of whether the
-- name is only in scope qualified.  I.e. even if method op is
-- in scope as M.op, we still allow plain 'op' on the LHS of
-- an instance decl
--
-- The "what" parameter says "method" or "associated type",
-- depending on what we are looking up
lookupInstDeclBndr :: Name -> SDoc -> RdrName -> RnM Name
lookupInstDeclBndr Name
cls SDoc
what RdrName
rdr
  = do { forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (RdrName -> Bool
isQual RdrName
rdr)
              (SDoc -> TcRn ()
addErr (RdrName -> SDoc
badQualBndrErr RdrName
rdr))
                -- In an instance decl you aren't allowed
                -- to use a qualified name for the method
                -- (Although it'd make perfect sense.)
       ; Either SDoc Name
mb_name <- Bool -> Name -> SDoc -> RdrName -> RnM (Either SDoc Name)
lookupSubBndrOcc
                          Bool
False -- False => we don't give deprecated
                                -- warnings when a deprecated class
                                -- method is defined. We only warn
                                -- when it's used
                          Name
cls SDoc
doc RdrName
rdr
       ; case Either SDoc Name
mb_name of
           Left SDoc
err -> do { SDoc -> TcRn ()
addErr SDoc
err; forall (m :: * -> *) a. Monad m => a -> m a
return (RdrName -> Name
mkUnboundNameRdr RdrName
rdr) }
           Right Name
nm -> forall (m :: * -> *) a. Monad m => a -> m a
return Name
nm }
  where
    doc :: SDoc
doc = SDoc
what SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"of class" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr Name
cls)

-----------------------------------------------
lookupFamInstName :: Maybe Name -> LocatedN RdrName
                  -> RnM (LocatedN Name)
-- Used for TyData and TySynonym family instances only,
-- See Note [Family instance binders]
lookupFamInstName :: Maybe Name -> LocatedN RdrName -> RnM (LocatedN Name)
lookupFamInstName (Just Name
cls) LocatedN RdrName
tc_rdr  -- Associated type; c.f GHC.Rename.Bind.rnMethodBind
  = forall a b ann.
(a -> TcM b)
-> GenLocated (SrcSpanAnn' ann) a
-> TcRn (GenLocated (SrcSpanAnn' ann) b)
wrapLocMA (Name -> SDoc -> RdrName -> RnM Name
lookupInstDeclBndr Name
cls (String -> SDoc
text String
"associated type")) LocatedN RdrName
tc_rdr
lookupFamInstName Maybe Name
Nothing LocatedN RdrName
tc_rdr     -- Family instance; tc_rdr is an *occurrence*
  = forall ann.
GenLocated (SrcSpanAnn' ann) RdrName
-> TcRn (GenLocated (SrcSpanAnn' ann) Name)
lookupLocatedOccRn LocatedN RdrName
tc_rdr

-----------------------------------------------
lookupConstructorFields :: Name -> RnM [FieldLabel]
-- Look up the fields of a given constructor
--   *  For constructors from this module, use the record field env,
--      which is itself gathered from the (as yet un-typechecked)
--      data type decls
--
--    * For constructors from imported modules, use the *type* environment
--      since imported modules are already compiled, the info is conveniently
--      right there

lookupConstructorFields :: Name -> RnM [FieldLabel]
lookupConstructorFields Name
con_name
  = do  { Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
        ; if Module -> Name -> Bool
nameIsLocalOrFrom Module
this_mod Name
con_name then
          do { RecFieldEnv
field_env <- TcRn RecFieldEnv
getRecFieldEnv
             ; String -> SDoc -> TcRn ()
traceTc String
"lookupCF" (forall a. Outputable a => a -> SDoc
ppr Name
con_name SDoc -> SDoc -> SDoc
$$ forall a. Outputable a => a -> SDoc
ppr (forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv RecFieldEnv
field_env Name
con_name) SDoc -> SDoc -> SDoc
$$ forall a. Outputable a => a -> SDoc
ppr RecFieldEnv
field_env)
             ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv RecFieldEnv
field_env Name
con_name forall a. Maybe a -> a -> a
`orElse` []) }
          else
          do { ConLike
con <- Name -> TcM ConLike
tcLookupConLike Name
con_name
             ; String -> SDoc -> TcRn ()
traceTc String
"lookupCF 2" (forall a. Outputable a => a -> SDoc
ppr ConLike
con)
             ; forall (m :: * -> *) a. Monad m => a -> m a
return (ConLike -> [FieldLabel]
conLikeFieldLabels ConLike
con) } }


-- In CPS style as `RnM r` is monadic
-- Reports an error if the name is an Exact or Orig and it can't find the name
-- Otherwise if it is not an Exact or Orig, returns k
lookupExactOrOrig :: RdrName -> (Name -> r) -> RnM r -> RnM r
lookupExactOrOrig :: forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
lookupExactOrOrig RdrName
rdr_name Name -> r
res RnM r
k
  = do { ExactOrOrigResult
men <- RdrName -> RnM ExactOrOrigResult
lookupExactOrOrig_base RdrName
rdr_name
       ; case ExactOrOrigResult
men of
          FoundExactOrOrig Name
n -> forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> r
res Name
n)
          ExactOrOrigError SDoc
e ->
            do { SDoc -> TcRn ()
addErr SDoc
e
               ; forall (m :: * -> *) a. Monad m => a -> m a
return (Name -> r
res (RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name)) }
          ExactOrOrigResult
NotExactOrOrig     -> RnM r
k }

-- Variant of 'lookupExactOrOrig' that does not report an error
-- See Note [Errors in lookup functions]
-- Calls k if the name is neither an Exact nor Orig
lookupExactOrOrig_maybe :: RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
lookupExactOrOrig_maybe :: forall r. RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
lookupExactOrOrig_maybe RdrName
rdr_name Maybe Name -> r
res RnM r
k
  = do { ExactOrOrigResult
men <- RdrName -> RnM ExactOrOrigResult
lookupExactOrOrig_base RdrName
rdr_name
       ; case ExactOrOrigResult
men of
           FoundExactOrOrig Name
n -> forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Name -> r
res (forall a. a -> Maybe a
Just Name
n))
           ExactOrOrigError SDoc
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Name -> r
res forall a. Maybe a
Nothing)
           ExactOrOrigResult
NotExactOrOrig     -> RnM r
k }

data ExactOrOrigResult = FoundExactOrOrig Name -- ^ Found an Exact Or Orig Name
                       | ExactOrOrigError SDoc -- ^ The RdrName was an Exact
                                                 -- or Orig, but there was an
                                                 -- error looking up the Name
                       | NotExactOrOrig -- ^ The RdrName is neither an Exact nor
                                        -- Orig

-- Does the actual looking up an Exact or Orig name, see 'ExactOrOrigResult'
lookupExactOrOrig_base :: RdrName -> RnM ExactOrOrigResult
lookupExactOrOrig_base :: RdrName -> RnM ExactOrOrigResult
lookupExactOrOrig_base RdrName
rdr_name
  | Just Name
n <- RdrName -> Maybe Name
isExact_maybe RdrName
rdr_name   -- This happens in derived code
  = Either SDoc Name -> ExactOrOrigResult
cvtEither forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Name -> RnM (Either SDoc Name)
lookupExactOcc_either Name
n
  | Just (Module
rdr_mod, OccName
rdr_occ) <- RdrName -> Maybe (Module, OccName)
isOrig_maybe RdrName
rdr_name
  = Name -> ExactOrOrigResult
FoundExactOrOrig forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b. Module -> OccName -> TcRnIf a b Name
lookupOrig Module
rdr_mod OccName
rdr_occ
  | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return ExactOrOrigResult
NotExactOrOrig
  where
    cvtEither :: Either SDoc Name -> ExactOrOrigResult
cvtEither (Left SDoc
e)  = SDoc -> ExactOrOrigResult
ExactOrOrigError SDoc
e
    cvtEither (Right Name
n) = Name -> ExactOrOrigResult
FoundExactOrOrig Name
n


{- Note [Errors in lookup functions]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Many of these lookup functions will attach an error if it can't find the Name it
is trying to lookup. However there are also _maybe and _either variants for many
of these functions.

These variants should *not* attach any errors, as there are
places where we want to attempt looking up a name, but it's not the end of the
world if we don't find it.

For example, see lookupThName_maybe: It calls lookupOccRn_maybe multiple
times for varying names in different namespaces. lookupOccRn_maybe should
therefore never attach an error, instead just return a Nothing.

For these _maybe/_either variant functions then, avoid calling further lookup
functions that can attach errors and instead call their _maybe/_either
counterparts.
-}

-----------------------------------------------
-- | Look up an occurrence of a field in record construction or pattern
-- matching (but not update).  When the -XDisambiguateRecordFields
-- flag is on, take account of the data constructor name to
-- disambiguate which field to use.
--
-- See Note [DisambiguateRecordFields] and Note [NoFieldSelectors].
lookupRecFieldOcc :: Maybe Name -- Nothing  => just look it up as usual
                                -- Just con => use data con to disambiguate
                  -> RdrName
                  -> RnM Name
lookupRecFieldOcc :: Maybe Name -> RdrName -> RnM Name
lookupRecFieldOcc Maybe Name
mb_con RdrName
rdr_name
  | Just Name
con <- Maybe Name
mb_con
  , Name -> Bool
isUnboundName Name
con  -- Avoid error cascade
  = forall (m :: * -> *) a. Monad m => a -> m a
return (RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name)
  | Just Name
con <- Maybe Name
mb_con
  = do { [FieldLabel]
flds <- Name -> RnM [FieldLabel]
lookupConstructorFields Name
con
       ; GlobalRdrEnv
env <- TcRn GlobalRdrEnv
getGlobalRdrEnv
       ; let lbl :: FastString
lbl      = OccName -> FastString
occNameFS (RdrName -> OccName
rdrNameOcc RdrName
rdr_name)
             mb_field :: Maybe (FieldLabel, GlobalRdrElt)
mb_field = do FieldLabel
fl <- forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find ((forall a. Eq a => a -> a -> Bool
== FastString
lbl) forall b c a. (b -> c) -> (a -> b) -> a -> c
. FieldLabel -> FastString
flLabel) [FieldLabel]
flds
                           -- We have the label, now check it is in scope.  If
                           -- there is a qualifier, use pickGREs to check that
                           -- the qualifier is correct, and return the filtered
                           -- GRE so we get import usage right (see #17853).
                           GlobalRdrElt
gre <- GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt
lookupGRE_FieldLabel GlobalRdrEnv
env FieldLabel
fl
                           if RdrName -> Bool
isQual RdrName
rdr_name
                             then do GlobalRdrElt
gre' <- forall a. [a] -> Maybe a
listToMaybe (RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
pickGREs RdrName
rdr_name [GlobalRdrElt
gre])
                                     forall (m :: * -> *) a. Monad m => a -> m a
return (FieldLabel
fl, GlobalRdrElt
gre')
                              else forall (m :: * -> *) a. Monad m => a -> m a
return (FieldLabel
fl, GlobalRdrElt
gre)
       ; case Maybe (FieldLabel, GlobalRdrElt)
mb_field of
           Just (FieldLabel
fl, GlobalRdrElt
gre) -> do { Bool -> GlobalRdrElt -> TcRn ()
addUsedGRE Bool
True GlobalRdrElt
gre
                                ; forall (m :: * -> *) a. Monad m => a -> m a
return (FieldLabel -> Name
flSelector FieldLabel
fl) }
           Maybe (FieldLabel, GlobalRdrElt)
Nothing        -> FieldsOrSelectors -> RdrName -> RnM Name
lookupGlobalOccRn' FieldsOrSelectors
WantBoth RdrName
rdr_name }
             -- See Note [Fall back on lookupGlobalOccRn in lookupRecFieldOcc]
  | Bool
otherwise
  -- This use of Global is right as we are looking up a selector which
  -- can only be defined at the top level.
  = FieldsOrSelectors -> RdrName -> RnM Name
lookupGlobalOccRn' FieldsOrSelectors
WantBoth RdrName
rdr_name

-- | Look up an occurrence of a field in a record update, returning the selector
-- name.
--
-- Unlike construction and pattern matching with @-XDisambiguateRecordFields@
-- (see 'lookupRecFieldOcc'), there is no data constructor to help disambiguate,
-- so this may be ambiguous if the field is in scope multiple times.  However we
-- ignore non-fields in scope with the same name if @-XDisambiguateRecordFields@
-- is on (see Note [DisambiguateRecordFields for updates]).
--
-- Here a field is in scope even if @NoFieldSelectors@ was enabled at its
-- definition site (see Note [NoFieldSelectors]).
lookupRecFieldOcc_update
  :: DuplicateRecordFields
  -> RdrName
  -> RnM AmbiguousResult
lookupRecFieldOcc_update :: DuplicateRecordFields -> RdrName -> RnM AmbiguousResult
lookupRecFieldOcc_update DuplicateRecordFields
dup_fields_ok RdrName
rdr_name = do
    Bool
disambig_ok <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.DisambiguateRecordFields
    let want :: FieldsOrSelectors
want | Bool
disambig_ok = FieldsOrSelectors
WantField
             | Bool
otherwise   = FieldsOrSelectors
WantBoth
    Maybe AmbiguousResult
mr <- DuplicateRecordFields
-> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
lookupGlobalOccRn_overloaded DuplicateRecordFields
dup_fields_ok FieldsOrSelectors
want RdrName
rdr_name
    case Maybe AmbiguousResult
mr of
        Just AmbiguousResult
r  -> forall (m :: * -> *) a. Monad m => a -> m a
return AmbiguousResult
r
        Maybe AmbiguousResult
Nothing  -- Try again if we previously looked only for fields, see
                 -- Note [DisambiguateRecordFields for updates]
          | Bool
disambig_ok -> do Maybe AmbiguousResult
mr' <- DuplicateRecordFields
-> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
lookupGlobalOccRn_overloaded DuplicateRecordFields
dup_fields_ok FieldsOrSelectors
WantBoth RdrName
rdr_name
                              case Maybe AmbiguousResult
mr' of
                                  Just AmbiguousResult
r -> forall (m :: * -> *) a. Monad m => a -> m a
return AmbiguousResult
r
                                  Maybe AmbiguousResult
Nothing -> RnM AmbiguousResult
unbound
          | Bool
otherwise   -> RnM AmbiguousResult
unbound
  where
    unbound :: RnM AmbiguousResult
unbound = GreName -> AmbiguousResult
UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> GreName
NormalGreName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> WhereLooking -> RdrName -> RnM Name
unboundName WhereLooking
WL_Global RdrName
rdr_name


{- Note [DisambiguateRecordFields]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we are looking up record fields in record construction or pattern
matching, we can take advantage of the data constructor name to
resolve fields that would otherwise be ambiguous (provided the
-XDisambiguateRecordFields flag is on).

For example, consider:

   data S = MkS { x :: Int }
   data T = MkT { x :: Int }

   e = MkS { x = 3 }

When we are renaming the occurrence of `x` in `e`, instead of looking
`x` up directly (and finding both fields), lookupRecFieldOcc will
search the fields of `MkS` to find the only possible `x` the user can
mean.

Of course, we still have to check the field is in scope, using
lookupGRE_FieldLabel.  The handling of qualified imports is slightly
subtle: the occurrence may be unqualified even if the field is
imported only qualified (but if the occurrence is qualified, the
qualifier must be correct). For example:

   module A where
     data S = MkS { x :: Int }
     data T = MkT { x :: Int }

   module B where
     import qualified A (S(..))
     import A (T(MkT))

     e1 = MkT   { x = 3 }   -- x not in scope, so fail
     e2 = A.MkS { B.x = 3 } -- module qualifier is wrong, so fail
     e3 = A.MkS { x = 3 }   -- x in scope (lack of module qualifier permitted)

In case `e1`, lookupGRE_FieldLabel will return Nothing.  In case `e2`,
lookupGRE_FieldLabel will return the GRE for `A.x`, but then the guard
will fail because the field RdrName `B.x` is qualified and pickGREs
rejects the GRE.  In case `e3`, lookupGRE_FieldLabel will return the
GRE for `A.x` and the guard will succeed because the field RdrName `x`
is unqualified.


Note [DisambiguateRecordFields for updates]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When we are looking up record fields in record update, we can take advantage of
the fact that we know we are looking for a field, even though we do not know the
data constructor name (as in Note [DisambiguateRecordFields]), provided the
-XDisambiguateRecordFields flag is on.

For example, consider:

   module N where
     f = ()

   {-# LANGUAGE DisambiguateRecordFields #-}
   module M where
     import N (f)
     data T = MkT { f :: Int }
     t = MkT { f = 1 }  -- unambiguous because MkT determines which field we mean
     u = t { f = 2 }    -- unambiguous because we ignore the non-field 'f'

This works by lookupRecFieldOcc_update using 'WantField :: FieldsOrSelectors'
when looking up the field name, so that 'filterFieldGREs' will later ignore any
non-fields in scope.  Of course, if a record update has two fields in scope with
the same name, it is still ambiguous.

If we do not find anything when looking only for fields, we try again allowing
fields or non-fields.  This leads to a better error message if the user
mistakenly tries to use a non-field name in a record update:

    f = ()
    e x = x { f = () }

Unlike with constructors or pattern-matching, we do not allow the module
qualifier to be omitted, because we do not have a data constructor from which to
determine it.


Note [Fall back on lookupGlobalOccRn in lookupRecFieldOcc]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Whenever we fail to find the field or it is not in scope, mb_field
will be False, and we fall back on looking it up normally using
lookupGlobalOccRn.  We don't report an error immediately because the
actual problem might be located elsewhere.  For example (#9975):

   data Test = Test { x :: Int }
   pattern Test wat = Test { x = wat }

Here there are multiple declarations of Test (as a data constructor
and as a pattern synonym), which will be reported as an error.  We
shouldn't also report an error about the occurrence of `x` in the
pattern synonym RHS.  However, if the pattern synonym gets added to
the environment first, we will try and fail to find `x` amongst the
(nonexistent) fields of the pattern synonym.

Alternatively, the scope check can fail due to Template Haskell.
Consider (#12130):

   module Foo where
     import M
     b = $(funny)

   module M(funny) where
     data T = MkT { x :: Int }
     funny :: Q Exp
     funny = [| MkT { x = 3 } |]

When we splice, `MkT` is not lexically in scope, so
lookupGRE_FieldLabel will fail.  But there is no need for
disambiguation anyway, because `x` is an original name, and
lookupGlobalOccRn will find it.
-}



-- | Used in export lists to lookup the children.
lookupSubBndrOcc_helper :: Bool -> Bool -> Name -> RdrName
                        -> RnM ChildLookupResult
lookupSubBndrOcc_helper :: Bool -> Bool -> Name -> RdrName -> RnM ChildLookupResult
lookupSubBndrOcc_helper Bool
must_have_parent Bool
warn_if_deprec Name
parent RdrName
rdr_name
  | Name -> Bool
isUnboundName Name
parent
    -- Avoid an error cascade
  = forall (m :: * -> *) a. Monad m => a -> m a
return (Parent -> GreName -> ChildLookupResult
FoundChild Parent
NoParent (Name -> GreName
NormalGreName (RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name)))

  | Bool
otherwise = do
  GlobalRdrEnv
gre_env <- TcRn GlobalRdrEnv
getGlobalRdrEnv

  let original_gres :: [GlobalRdrElt]
original_gres = GlobalRdrEnv -> OccName -> [GlobalRdrElt]
lookupGlobalRdrEnv GlobalRdrEnv
gre_env (RdrName -> OccName
rdrNameOcc RdrName
rdr_name)
  -- Disambiguate the lookup based on the parent information.
  -- The remaining GREs are things that we *could* export here, note that
  -- this includes things which have `NoParent`. Those are sorted in
  -- `checkPatSynParent`.
  String -> SDoc -> TcRn ()
traceRn String
"parent" (forall a. Outputable a => a -> SDoc
ppr Name
parent)
  String -> SDoc -> TcRn ()
traceRn String
"lookupExportChild original_gres:" (forall a. Outputable a => a -> SDoc
ppr [GlobalRdrElt]
original_gres)
  String -> SDoc -> TcRn ()
traceRn String
"lookupExportChild picked_gres:" (forall a. Outputable a => a -> SDoc
ppr ([GlobalRdrElt] -> DisambigInfo
picked_gres [GlobalRdrElt]
original_gres) SDoc -> SDoc -> SDoc
$$ forall a. Outputable a => a -> SDoc
ppr Bool
must_have_parent)
  case [GlobalRdrElt] -> DisambigInfo
picked_gres [GlobalRdrElt]
original_gres of
    DisambigInfo
NoOccurrence ->
      [GlobalRdrElt] -> RnM ChildLookupResult
noMatchingParentErr [GlobalRdrElt]
original_gres
    UniqueOccurrence GlobalRdrElt
g ->
      if Bool
must_have_parent then [GlobalRdrElt] -> RnM ChildLookupResult
noMatchingParentErr [GlobalRdrElt]
original_gres
                          else GlobalRdrElt -> RnM ChildLookupResult
checkFld GlobalRdrElt
g
    DisambiguatedOccurrence GlobalRdrElt
g ->
      GlobalRdrElt -> RnM ChildLookupResult
checkFld GlobalRdrElt
g
    AmbiguousOccurrence NonEmpty GlobalRdrElt
gres ->
      NonEmpty GlobalRdrElt -> RnM ChildLookupResult
mkNameClashErr NonEmpty GlobalRdrElt
gres
    where
        -- Convert into FieldLabel if necessary
        checkFld :: GlobalRdrElt -> RnM ChildLookupResult
        checkFld :: GlobalRdrElt -> RnM ChildLookupResult
checkFld g :: GlobalRdrElt
g@GRE{GreName
gre_name :: GlobalRdrElt -> GreName
gre_name :: GreName
gre_name,Parent
gre_par :: GlobalRdrElt -> Parent
gre_par :: Parent
gre_par} = do
          Bool -> GlobalRdrElt -> TcRn ()
addUsedGRE Bool
warn_if_deprec GlobalRdrElt
g
          forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Parent -> GreName -> ChildLookupResult
FoundChild Parent
gre_par GreName
gre_name

        -- Called when we find no matching GREs after disambiguation but
        -- there are three situations where this happens.
        -- 1. There were none to begin with.
        -- 2. None of the matching ones were the parent but
        --  a. They were from an overloaded record field so we can report
        --     a better error
        --  b. The original lookup was actually ambiguous.
        --     For example, the case where overloading is off and two
        --     record fields are in scope from different record
        --     constructors, neither of which is the parent.
        noMatchingParentErr :: [GlobalRdrElt] -> RnM ChildLookupResult
        noMatchingParentErr :: [GlobalRdrElt] -> RnM ChildLookupResult
noMatchingParentErr [GlobalRdrElt]
original_gres = do
          String -> SDoc -> TcRn ()
traceRn String
"npe" (forall a. Outputable a => a -> SDoc
ppr [GlobalRdrElt]
original_gres)
          Bool
dup_fields_ok <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.DuplicateRecordFields
          case [GlobalRdrElt]
original_gres of
            [] ->  forall (m :: * -> *) a. Monad m => a -> m a
return ChildLookupResult
NameNotFound
            [GlobalRdrElt
g] -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Name -> GreName -> [Name] -> ChildLookupResult
IncorrectParent Name
parent
                              (GlobalRdrElt -> GreName
gre_name GlobalRdrElt
g)
                              [Name
p | Just Name
p <- [GlobalRdrElt -> Maybe Name
getParent GlobalRdrElt
g]]
            gss :: [GlobalRdrElt]
gss@(GlobalRdrElt
g:gss' :: [GlobalRdrElt]
gss'@(GlobalRdrElt
_:[GlobalRdrElt]
_)) ->
              if forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all GlobalRdrElt -> Bool
isRecFldGRE [GlobalRdrElt]
gss Bool -> Bool -> Bool
&& Bool
dup_fields_ok
                then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$
                      Name -> GreName -> [Name] -> ChildLookupResult
IncorrectParent Name
parent
                        (GlobalRdrElt -> GreName
gre_name GlobalRdrElt
g)
                        [Name
p | GlobalRdrElt
x <- [GlobalRdrElt]
gss, Just Name
p <- [GlobalRdrElt -> Maybe Name
getParent GlobalRdrElt
x]]
                else NonEmpty GlobalRdrElt -> RnM ChildLookupResult
mkNameClashErr forall a b. (a -> b) -> a -> b
$ GlobalRdrElt
g forall a. a -> [a] -> NonEmpty a
NE.:| [GlobalRdrElt]
gss'

        mkNameClashErr :: NE.NonEmpty GlobalRdrElt -> RnM ChildLookupResult
        mkNameClashErr :: NonEmpty GlobalRdrElt -> RnM ChildLookupResult
mkNameClashErr NonEmpty GlobalRdrElt
gres = do
          RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
addNameClashErrRn RdrName
rdr_name NonEmpty GlobalRdrElt
gres
          forall (m :: * -> *) a. Monad m => a -> m a
return (Parent -> GreName -> ChildLookupResult
FoundChild (GlobalRdrElt -> Parent
gre_par (forall a. NonEmpty a -> a
NE.head NonEmpty GlobalRdrElt
gres)) (GlobalRdrElt -> GreName
gre_name (forall a. NonEmpty a -> a
NE.head NonEmpty GlobalRdrElt
gres)))

        getParent :: GlobalRdrElt -> Maybe Name
        getParent :: GlobalRdrElt -> Maybe Name
getParent (GRE { gre_par :: GlobalRdrElt -> Parent
gre_par = Parent
p } ) =
          case Parent
p of
            ParentIs Name
cur_parent -> forall a. a -> Maybe a
Just Name
cur_parent
            Parent
NoParent -> forall a. Maybe a
Nothing

        picked_gres :: [GlobalRdrElt] -> DisambigInfo
        -- For Unqual, find GREs that are in scope qualified or unqualified
        -- For Qual,   find GREs that are in scope with that qualification
        picked_gres :: [GlobalRdrElt] -> DisambigInfo
picked_gres [GlobalRdrElt]
gres
          | RdrName -> Bool
isUnqual RdrName
rdr_name
          = forall a. Monoid a => [a] -> a
mconcat (forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrElt -> DisambigInfo
right_parent [GlobalRdrElt]
gres)
          | Bool
otherwise
          = forall a. Monoid a => [a] -> a
mconcat (forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrElt -> DisambigInfo
right_parent (RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]
pickGREs RdrName
rdr_name [GlobalRdrElt]
gres))

        right_parent :: GlobalRdrElt -> DisambigInfo
        right_parent :: GlobalRdrElt -> DisambigInfo
right_parent GlobalRdrElt
p
          = case GlobalRdrElt -> Maybe Name
getParent GlobalRdrElt
p of
               Just Name
cur_parent
                  | Name
parent forall a. Eq a => a -> a -> Bool
== Name
cur_parent -> GlobalRdrElt -> DisambigInfo
DisambiguatedOccurrence GlobalRdrElt
p
                  | Bool
otherwise            -> DisambigInfo
NoOccurrence
               Maybe Name
Nothing                   -> GlobalRdrElt -> DisambigInfo
UniqueOccurrence GlobalRdrElt
p


-- This domain specific datatype is used to record why we decided it was
-- possible that a GRE could be exported with a parent.
data DisambigInfo
       = NoOccurrence
          -- The GRE could never be exported. It has the wrong parent.
       | UniqueOccurrence GlobalRdrElt
          -- The GRE has no parent. It could be a pattern synonym.
       | DisambiguatedOccurrence GlobalRdrElt
          -- The parent of the GRE is the correct parent
       | AmbiguousOccurrence (NE.NonEmpty GlobalRdrElt)
          -- For example, two normal identifiers with the same name are in
          -- scope. They will both be resolved to "UniqueOccurrence" and the
          -- monoid will combine them to this failing case.

instance Outputable DisambigInfo where
  ppr :: DisambigInfo -> SDoc
ppr DisambigInfo
NoOccurrence = String -> SDoc
text String
"NoOccurence"
  ppr (UniqueOccurrence GlobalRdrElt
gre) = String -> SDoc
text String
"UniqueOccurrence:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr GlobalRdrElt
gre
  ppr (DisambiguatedOccurrence GlobalRdrElt
gre) = String -> SDoc
text String
"DiambiguatedOccurrence:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr GlobalRdrElt
gre
  ppr (AmbiguousOccurrence NonEmpty GlobalRdrElt
gres)    = String -> SDoc
text String
"Ambiguous:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr NonEmpty GlobalRdrElt
gres

instance Semi.Semigroup DisambigInfo where
  -- This is the key line: We prefer disambiguated occurrences to other
  -- names.
  DisambigInfo
_ <> :: DisambigInfo -> DisambigInfo -> DisambigInfo
<> DisambiguatedOccurrence GlobalRdrElt
g' = GlobalRdrElt -> DisambigInfo
DisambiguatedOccurrence GlobalRdrElt
g'
  DisambiguatedOccurrence GlobalRdrElt
g' <> DisambigInfo
_ = GlobalRdrElt -> DisambigInfo
DisambiguatedOccurrence GlobalRdrElt
g'

  DisambigInfo
NoOccurrence <> DisambigInfo
m = DisambigInfo
m
  DisambigInfo
m <> DisambigInfo
NoOccurrence = DisambigInfo
m
  UniqueOccurrence GlobalRdrElt
g <> UniqueOccurrence GlobalRdrElt
g'
    = NonEmpty GlobalRdrElt -> DisambigInfo
AmbiguousOccurrence forall a b. (a -> b) -> a -> b
$ GlobalRdrElt
g forall a. a -> [a] -> NonEmpty a
NE.:| [GlobalRdrElt
g']
  UniqueOccurrence GlobalRdrElt
g <> AmbiguousOccurrence NonEmpty GlobalRdrElt
gs
    = NonEmpty GlobalRdrElt -> DisambigInfo
AmbiguousOccurrence (GlobalRdrElt
g forall a. a -> NonEmpty a -> NonEmpty a
`NE.cons` NonEmpty GlobalRdrElt
gs)
  AmbiguousOccurrence NonEmpty GlobalRdrElt
gs <> UniqueOccurrence GlobalRdrElt
g'
    = NonEmpty GlobalRdrElt -> DisambigInfo
AmbiguousOccurrence (GlobalRdrElt
g' forall a. a -> NonEmpty a -> NonEmpty a
`NE.cons` NonEmpty GlobalRdrElt
gs)
  AmbiguousOccurrence NonEmpty GlobalRdrElt
gs <> AmbiguousOccurrence NonEmpty GlobalRdrElt
gs'
    = NonEmpty GlobalRdrElt -> DisambigInfo
AmbiguousOccurrence (NonEmpty GlobalRdrElt
gs forall a. Semigroup a => a -> a -> a
Semi.<> NonEmpty GlobalRdrElt
gs')

instance Monoid DisambigInfo where
  mempty :: DisambigInfo
mempty = DisambigInfo
NoOccurrence
  mappend :: DisambigInfo -> DisambigInfo -> DisambigInfo
mappend = forall a. Semigroup a => a -> a -> a
(Semi.<>)

-- Lookup SubBndrOcc can never be ambiguous
--
-- Records the result of looking up a child.
data ChildLookupResult
      = NameNotFound                --  We couldn't find a suitable name
      | IncorrectParent Name        -- Parent
                        GreName     -- Child we were looking for
                        [Name]      -- List of possible parents
      | FoundChild Parent GreName   --  We resolved to a child

-- | Specialised version of msum for RnM ChildLookupResult
combineChildLookupResult :: [RnM ChildLookupResult] -> RnM ChildLookupResult
combineChildLookupResult :: [RnM ChildLookupResult] -> RnM ChildLookupResult
combineChildLookupResult [] = forall (m :: * -> *) a. Monad m => a -> m a
return ChildLookupResult
NameNotFound
combineChildLookupResult (RnM ChildLookupResult
x:[RnM ChildLookupResult]
xs) = do
  ChildLookupResult
res <- RnM ChildLookupResult
x
  case ChildLookupResult
res of
    ChildLookupResult
NameNotFound -> [RnM ChildLookupResult] -> RnM ChildLookupResult
combineChildLookupResult [RnM ChildLookupResult]
xs
    ChildLookupResult
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return ChildLookupResult
res

instance Outputable ChildLookupResult where
  ppr :: ChildLookupResult -> SDoc
ppr ChildLookupResult
NameNotFound = String -> SDoc
text String
"NameNotFound"
  ppr (FoundChild Parent
p GreName
n) = String -> SDoc
text String
"Found:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr Parent
p SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr GreName
n
  ppr (IncorrectParent Name
p GreName
n [Name]
ns) = String -> SDoc
text String
"IncorrectParent"
                                  SDoc -> SDoc -> SDoc
<+> [SDoc] -> SDoc
hsep [forall a. Outputable a => a -> SDoc
ppr Name
p, forall a. Outputable a => a -> SDoc
ppr GreName
n, forall a. Outputable a => a -> SDoc
ppr [Name]
ns]

lookupSubBndrOcc :: Bool
                 -> Name     -- Parent
                 -> SDoc
                 -> RdrName
                 -> RnM (Either SDoc Name)
-- Find all the things the rdr-name maps to
-- and pick the one with the right parent namep
lookupSubBndrOcc :: Bool -> Name -> SDoc -> RdrName -> RnM (Either SDoc Name)
lookupSubBndrOcc Bool
warn_if_deprec Name
the_parent SDoc
doc RdrName
rdr_name = do
  ChildLookupResult
res <-
    forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
lookupExactOrOrig RdrName
rdr_name (Parent -> GreName -> ChildLookupResult
FoundChild Parent
NoParent forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> GreName
NormalGreName) forall a b. (a -> b) -> a -> b
$
      -- This happens for built-in classes, see mod052 for example
      Bool -> Bool -> Name -> RdrName -> RnM ChildLookupResult
lookupSubBndrOcc_helper Bool
True Bool
warn_if_deprec Name
the_parent RdrName
rdr_name
  case ChildLookupResult
res of
    ChildLookupResult
NameNotFound -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left (SDoc -> RdrName -> SDoc
unknownSubordinateErr SDoc
doc RdrName
rdr_name))
    FoundChild Parent
_p GreName
child -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right (GreName -> Name
greNameMangledName GreName
child))
    IncorrectParent {}
         -- See [Mismatched class methods and associated type families]
         -- in TcInstDecls.
      -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. a -> Either a b
Left (SDoc -> RdrName -> SDoc
unknownSubordinateErr SDoc
doc RdrName
rdr_name)

{-
Note [Family instance binders]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
  data family F a
  data instance F T = X1 | X2

The 'data instance' decl has an *occurrence* of F (and T), and *binds*
X1 and X2.  (This is unlike a normal data type declaration which would
bind F too.)  So we want an AvailTC F [X1,X2].

Now consider a similar pair:
  class C a where
    data G a
  instance C S where
    data G S = Y1 | Y2

The 'data G S' *binds* Y1 and Y2, and has an *occurrence* of G.

But there is a small complication: in an instance decl, we don't use
qualified names on the LHS; instead we use the class to disambiguate.
Thus:
  module M where
    import Blib( G )
    class C a where
      data G a
    instance C S where
      data G S = Y1 | Y2
Even though there are two G's in scope (M.G and Blib.G), the occurrence
of 'G' in the 'instance C S' decl is unambiguous, because C has only
one associated type called G. This is exactly what happens for methods,
and it is only consistent to do the same thing for types. That's the
role of the function lookupTcdName; the (Maybe Name) give the class of
the encloseing instance decl, if any.

Note [Looking up Exact RdrNames]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Exact RdrNames are generated by:

* Template Haskell (See Note [Binders in Template Haskell] in GHC.ThToHs)
* Derived instances (See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate)

For data types and classes have Exact system Names in the binding
positions for constructors, TyCons etc.  For example
    [d| data T = MkT Int |]
when we splice in and convert to HsSyn RdrName, we'll get
    data (Exact (system Name "T")) = (Exact (system Name "MkT")) ...
These System names are generated by GHC.ThToHs.thRdrName

But, constructors and the like need External Names, not System Names!
So we do the following

 * In GHC.Rename.Env.newTopSrcBinder we spot Exact RdrNames that wrap a
   non-External Name, and make an External name for it. This is
   the name that goes in the GlobalRdrEnv

 * When looking up an occurrence of an Exact name, done in
   GHC.Rename.Env.lookupExactOcc, we find the Name with the right unique in the
   GlobalRdrEnv, and use the one from the envt -- it will be an
   External Name in the case of the data type/constructor above.

 * Exact names are also use for purely local binders generated
   by TH, such as    \x_33. x_33
   Both binder and occurrence are Exact RdrNames.  The occurrence
   gets looked up in the LocalRdrEnv by GHC.Rename.Env.lookupOccRn, and
   misses, because lookupLocalRdrEnv always returns Nothing for
   an Exact Name.  Now we fall through to lookupExactOcc, which
   will find the Name is not in the GlobalRdrEnv, so we just use
   the Exact supplied Name.

Note [Splicing Exact names]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider the splice $(do { x <- newName "x"; return (VarE x) })
This will generate a (HsExpr RdrName) term that mentions the
Exact RdrName "x_56" (or whatever), but does not bind it.  So
when looking such Exact names we want to check that it's in scope,
otherwise the type checker will get confused.  To do this we need to
keep track of all the Names in scope, and the LocalRdrEnv does just that;
we consult it with RdrName.inLocalRdrEnvScope.

There is another wrinkle.  With TH and -XDataKinds, consider
   $( [d| data Nat = Zero
          data T = MkT (Proxy 'Zero)  |] )
After splicing, but before renaming we get this:
   data Nat_77{tc} = Zero_78{d}
   data T_79{tc} = MkT_80{d} (Proxy 'Zero_78{tc})  |] )
The occurrence of 'Zero in the data type for T has the right unique,
but it has a TcClsName name-space in its OccName.  (This is set by
the ctxt_ns argument of Convert.thRdrName.)  When we check that is
in scope in the GlobalRdrEnv, we need to look up the DataName namespace
too.  (An alternative would be to make the GlobalRdrEnv also have
a Name -> GRE mapping.)

Note [Template Haskell ambiguity]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The GlobalRdrEnv invariant says that if
  occ -> [gre1, ..., gren]
then the gres have distinct Names (INVARIANT 1 of GlobalRdrEnv).
This is guaranteed by extendGlobalRdrEnvRn (the dups check in add_gre).

So how can we get multiple gres in lookupExactOcc_maybe?  Because in
TH we might use the same TH NameU in two different name spaces.
eg (#7241):
   $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
Here we generate a type constructor and data constructor with the same
unique, but different name spaces.

It'd be nicer to rule this out in extendGlobalRdrEnvRn, but that would
mean looking up the OccName in every name-space, just in case, and that
seems a bit brutal.  So it's just done here on lookup.  But we might
need to revisit that choice.

Note [Usage for sub-bndrs]
~~~~~~~~~~~~~~~~~~~~~~~~~~
If you have this
   import qualified M( C( f ) )
   instance M.C T where
     f x = x
then is the qualified import M.f used?  Obviously yes.
But the RdrName used in the instance decl is unqualified.  In effect,
we fill in the qualification by looking for f's whose class is M.C
But when adding to the UsedRdrNames we must make that qualification
explicit (saying "used  M.f"), otherwise we get "Redundant import of M.f".

So we make up a suitable (fake) RdrName.  But be careful
   import qualified M
   import M( C(f) )
   instance C T where
     f x = x
Here we want to record a use of 'f', not of 'M.f', otherwise
we'll miss the fact that the qualified import is redundant.

--------------------------------------------------
--              Occurrences
--------------------------------------------------
-}


lookupLocatedOccRn :: GenLocated (SrcSpanAnn' ann) RdrName
                   -> TcRn (GenLocated (SrcSpanAnn' ann) Name)
lookupLocatedOccRn :: forall ann.
GenLocated (SrcSpanAnn' ann) RdrName
-> TcRn (GenLocated (SrcSpanAnn' ann) Name)
lookupLocatedOccRn = forall a b ann.
(a -> TcM b)
-> GenLocated (SrcSpanAnn' ann) a
-> TcRn (GenLocated (SrcSpanAnn' ann) b)
wrapLocMA RdrName -> RnM Name
lookupOccRn

lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
-- Just look in the local environment
lookupLocalOccRn_maybe :: RdrName -> RnM (Maybe Name)
lookupLocalOccRn_maybe RdrName
rdr_name
  = do { LocalRdrEnv
local_env <- RnM LocalRdrEnv
getLocalRdrEnv
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (LocalRdrEnv -> RdrName -> Maybe Name
lookupLocalRdrEnv LocalRdrEnv
local_env RdrName
rdr_name) }

lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, ThLevel))
-- Just look in the local environment
lookupLocalOccThLvl_maybe :: Name -> RnM (Maybe (TopLevelFlag, Arity))
lookupLocalOccThLvl_maybe Name
name
  = do { TcLclEnv
lcl_env <- forall gbl lcl. TcRnIf gbl lcl lcl
getLclEnv
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. NameEnv a -> Name -> Maybe a
lookupNameEnv (TcLclEnv -> ThBindEnv
tcl_th_bndrs TcLclEnv
lcl_env) Name
name) }

-- lookupOccRn looks up an occurrence of a RdrName
lookupOccRn :: RdrName -> RnM Name
lookupOccRn :: RdrName -> RnM Name
lookupOccRn RdrName
rdr_name
  = do { Maybe Name
mb_name <- RdrName -> RnM (Maybe Name)
lookupOccRn_maybe RdrName
rdr_name
       ; case Maybe Name
mb_name of
           Just Name
name -> forall (m :: * -> *) a. Monad m => a -> m a
return Name
name
           Maybe Name
Nothing   -> RdrName -> RnM Name
reportUnboundName RdrName
rdr_name }

-- Only used in one place, to rename pattern synonym binders.
-- See Note [Renaming pattern synonym variables] in GHC.Rename.Bind
lookupLocalOccRn :: RdrName -> RnM Name
lookupLocalOccRn :: RdrName -> RnM Name
lookupLocalOccRn RdrName
rdr_name
  = do { Maybe Name
mb_name <- RdrName -> RnM (Maybe Name)
lookupLocalOccRn_maybe RdrName
rdr_name
       ; case Maybe Name
mb_name of
           Just Name
name -> forall (m :: * -> *) a. Monad m => a -> m a
return Name
name
           Maybe Name
Nothing   -> WhereLooking -> RdrName -> RnM Name
unboundName WhereLooking
WL_LocalOnly RdrName
rdr_name }

-- lookupTypeOccRn looks up an optionally promoted RdrName.
-- Used for looking up type variables.
lookupTypeOccRn :: RdrName -> RnM Name
-- see Note [Demotion]
lookupTypeOccRn :: RdrName -> RnM Name
lookupTypeOccRn RdrName
rdr_name
  | OccName -> Bool
isVarOcc (RdrName -> OccName
rdrNameOcc RdrName
rdr_name)  -- See Note [Promoted variables in types]
  = RdrName -> RnM Name
badVarInType RdrName
rdr_name
  | Bool
otherwise
  = do { Maybe Name
mb_name <- RdrName -> RnM (Maybe Name)
lookupOccRn_maybe RdrName
rdr_name
       ; case Maybe Name
mb_name of
             Just Name
name -> forall (m :: * -> *) a. Monad m => a -> m a
return Name
name
             Maybe Name
Nothing   -> RdrName -> RnM Name
lookup_demoted RdrName
rdr_name }

lookup_demoted :: RdrName -> RnM Name
lookup_demoted :: RdrName -> RnM Name
lookup_demoted RdrName
rdr_name
  | Just RdrName
demoted_rdr <- RdrName -> Maybe RdrName
demoteRdrName RdrName
rdr_name
    -- Maybe it's the name of a *data* constructor
  = do { Bool
data_kinds <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.DataKinds
       ; Bool
star_is_type <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.StarIsType
       ; let star_info :: SDoc
star_info = Bool -> RdrName -> SDoc
starInfo Bool
star_is_type RdrName
rdr_name
       ; if Bool
data_kinds
            then do { Maybe Name
mb_demoted_name <- RdrName -> RnM (Maybe Name)
lookupOccRn_maybe RdrName
demoted_rdr
                    ; case Maybe Name
mb_demoted_name of
                        Maybe Name
Nothing -> WhereLooking -> RdrName -> SDoc -> RnM Name
unboundNameX WhereLooking
WL_Any RdrName
rdr_name SDoc
star_info
                        Just Name
demoted_name ->
                          do { forall gbl lcl.
WarningFlag -> TcRnIf gbl lcl () -> TcRnIf gbl lcl ()
whenWOptM WarningFlag
Opt_WarnUntickedPromotedConstructors forall a b. (a -> b) -> a -> b
$
                               WarnReason -> SDoc -> TcRn ()
addWarn
                                 (WarningFlag -> WarnReason
Reason WarningFlag
Opt_WarnUntickedPromotedConstructors)
                                 (forall a. Outputable a => a -> SDoc
untickedPromConstrWarn Name
demoted_name)
                             ; forall (m :: * -> *) a. Monad m => a -> m a
return Name
demoted_name } }
            else do { -- We need to check if a data constructor of this name is
                      -- in scope to give good error messages. However, we do
                      -- not want to give an additional error if the data
                      -- constructor happens to be out of scope! See #13947.
                      Maybe Name
mb_demoted_name <- forall a. TcRn a -> TcRn a
discardErrs forall a b. (a -> b) -> a -> b
$
                                         RdrName -> RnM (Maybe Name)
lookupOccRn_maybe RdrName
demoted_rdr
                    ; let suggestion :: SDoc
suggestion | forall a. Maybe a -> Bool
isJust Maybe Name
mb_demoted_name = SDoc
suggest_dk
                                     | Bool
otherwise = SDoc
star_info
                    ; WhereLooking -> RdrName -> SDoc -> RnM Name
unboundNameX WhereLooking
WL_Any RdrName
rdr_name SDoc
suggestion } }

  | Bool
otherwise
  = RdrName -> RnM Name
reportUnboundName RdrName
rdr_name

  where
    suggest_dk :: SDoc
suggest_dk = String -> SDoc
text String
"A data constructor of that name is in scope; did you mean DataKinds?"
    untickedPromConstrWarn :: a -> SDoc
untickedPromConstrWarn a
name =
      String -> SDoc
text String
"Unticked promoted constructor" SDoc -> SDoc -> SDoc
<> SDoc
colon SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr a
name) SDoc -> SDoc -> SDoc
<> SDoc
dot
      SDoc -> SDoc -> SDoc
$$
      [SDoc] -> SDoc
hsep [ String -> SDoc
text String
"Use"
           , SDoc -> SDoc
quotes (Char -> SDoc
char Char
'\'' SDoc -> SDoc -> SDoc
<> forall a. Outputable a => a -> SDoc
ppr a
name)
           , String -> SDoc
text String
"instead of"
           , SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr a
name) SDoc -> SDoc -> SDoc
<> SDoc
dot ]

-- If the given RdrName can be promoted to the type level and its promoted variant is in scope,
-- lookup_promoted returns the corresponding type-level Name.
-- Otherwise, the function returns Nothing.
-- See Note [Promotion] below.
lookup_promoted :: RdrName -> RnM (Maybe Name)
lookup_promoted :: RdrName -> RnM (Maybe Name)
lookup_promoted RdrName
rdr_name
  | Just RdrName
promoted_rdr <- RdrName -> Maybe RdrName
promoteRdrName RdrName
rdr_name
  = RdrName -> RnM (Maybe Name)
lookupOccRn_maybe RdrName
promoted_rdr
  | Bool
otherwise
  = forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing

badVarInType :: RdrName -> RnM Name
badVarInType :: RdrName -> RnM Name
badVarInType RdrName
rdr_name
  = do { SDoc -> TcRn ()
addErr (String -> SDoc
text String
"Illegal promoted term variable in a type:"
                 SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name) }

{- Note [Promoted variables in types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider this (#12686):
   x = True
   data Bad = Bad 'x

The parser treats the quote in 'x as saying "use the term
namespace", so we'll get (Bad x{v}), with 'x' in the
VarName namespace.  If we don't test for this, the renamer
will happily rename it to the x bound at top level, and then
the typecheck falls over because it doesn't have 'x' in scope
when kind-checking.

Note [Demotion]
~~~~~~~~~~~~~~~
When the user writes:
  data Nat = Zero | Succ Nat
  foo :: f Zero -> Int

'Zero' in the type signature of 'foo' is parsed as:
  HsTyVar ("Zero", TcClsName)

When the renamer hits this occurrence of 'Zero' it's going to realise
that it's not in scope. But because it is renaming a type, it knows
that 'Zero' might be a promoted data constructor, so it will demote
its namespace to DataName and do a second lookup.

The final result (after the renamer) will be:
  HsTyVar ("Zero", DataName)

Note [Promotion]
~~~~~~~~~~~~~~~
When the user mentions a type constructor or a type variable in a
term-level context, then we report that a value identifier was expected
instead of a type-level one. That makes error messages more precise.
Previously, such errors contained only the info that a given value was out of scope (#18740).
We promote the namespace of RdrName and look up after that
(see the functions promotedRdrName and lookup_promoted).

In particular, we have the following error message
  • Illegal term-level use of the type constructor ‘Int’
      imported from ‘Prelude’ (and originally defined in ‘GHC.Types’)
  • In the first argument of ‘id’, namely ‘Int’
    In the expression: id Int
    In an equation for ‘x’: x = id Int

when the user writes the following declaration

  x = id Int
-}

lookupOccRnX_maybe :: (RdrName -> RnM (Maybe r)) -> (Name -> r) -> RdrName
                   -> RnM (Maybe r)
lookupOccRnX_maybe :: forall r.
(RdrName -> RnM (Maybe r))
-> (Name -> r) -> RdrName -> RnM (Maybe r)
lookupOccRnX_maybe RdrName -> RnM (Maybe r)
globalLookup Name -> r
wrapper RdrName
rdr_name
  = forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall a b. (a -> b) -> a -> b
$
      [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Name -> r
wrapper forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RdrName -> RnM (Maybe Name)
lookupLocalOccRn_maybe RdrName
rdr_name
      , RdrName -> RnM (Maybe r)
globalLookup RdrName
rdr_name ]

-- Used outside this module only by TH name reification (lookupName, lookupThName_maybe)
lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
lookupOccRn_maybe :: RdrName -> RnM (Maybe Name)
lookupOccRn_maybe = forall r.
(RdrName -> RnM (Maybe r))
-> (Name -> r) -> RdrName -> RnM (Maybe r)
lookupOccRnX_maybe RdrName -> RnM (Maybe Name)
lookupGlobalOccRn_maybe forall a. a -> a
id

-- | Look up a 'RdrName' used as a variable in an expression.
--
-- This may be a local variable, global variable, or one or more record selector
-- functions.  It will not return record fields created with the
-- @NoFieldSelectors@ extension (see Note [NoFieldSelectors]).  The
-- 'DuplicateRecordFields' argument controls whether ambiguous fields will be
-- allowed (resulting in an 'AmbiguousFields' result being returned).
--
-- If the name is not in scope at the term level, but its promoted equivalent is
-- in scope at the type level, the lookup will succeed (so that the type-checker
-- can report a more informative error later).  See Note [Promotion].
--
lookupExprOccRn
  :: DuplicateRecordFields -> RdrName
  -> RnM (Maybe AmbiguousResult)
lookupExprOccRn :: DuplicateRecordFields -> RdrName -> RnM (Maybe AmbiguousResult)
lookupExprOccRn DuplicateRecordFields
dup_fields_ok RdrName
rdr_name
  = do { Maybe AmbiguousResult
mb_name <- forall r.
(RdrName -> RnM (Maybe r))
-> (Name -> r) -> RdrName -> RnM (Maybe r)
lookupOccRnX_maybe RdrName -> RnM (Maybe AmbiguousResult)
global_lookup (GreName -> AmbiguousResult
UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> GreName
NormalGreName) RdrName
rdr_name
       ; case Maybe AmbiguousResult
mb_name of
           Maybe AmbiguousResult
Nothing   -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap @Maybe (GreName -> AmbiguousResult
UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> GreName
NormalGreName) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> RdrName -> RnM (Maybe Name)
lookup_promoted RdrName
rdr_name
                        -- See Note [Promotion].
                        -- We try looking up the name as a
                        -- type constructor or type variable, if
                        -- we failed to look up the name at the term level.
           Maybe AmbiguousResult
p         -> forall (m :: * -> *) a. Monad m => a -> m a
return Maybe AmbiguousResult
p }

  where
    global_lookup :: RdrName -> RnM (Maybe AmbiguousResult)
    global_lookup :: RdrName -> RnM (Maybe AmbiguousResult)
global_lookup = DuplicateRecordFields
-> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
lookupGlobalOccRn_overloaded DuplicateRecordFields
dup_fields_ok FieldsOrSelectors
WantNormal

lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
-- Looks up a RdrName occurrence in the top-level
-- environment, including using lookupQualifiedNameGHCi
-- for the GHCi case, but first tries to find an Exact or Orig name.
-- No filter function; does not report an error on failure
-- See Note [Errors in lookup functions]
-- Uses addUsedRdrName to record use and deprecations
--
-- Used directly only by getLocalNonValBinders (new_assoc).
lookupGlobalOccRn_maybe :: RdrName -> RnM (Maybe Name)
lookupGlobalOccRn_maybe RdrName
rdr_name =
  forall r. RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
lookupExactOrOrig_maybe RdrName
rdr_name forall a. a -> a
id (FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
lookupGlobalOccRn_base FieldsOrSelectors
WantNormal RdrName
rdr_name)

lookupGlobalOccRn :: RdrName -> RnM Name
-- lookupGlobalOccRn is like lookupOccRn, except that it looks in the global
-- environment.  Adds an error message if the RdrName is not in scope.
-- You usually want to use "lookupOccRn" which also looks in the local
-- environment.
--
-- Used by exports_from_avail
lookupGlobalOccRn :: RdrName -> RnM Name
lookupGlobalOccRn = FieldsOrSelectors -> RdrName -> RnM Name
lookupGlobalOccRn' FieldsOrSelectors
WantNormal

lookupGlobalOccRn' :: FieldsOrSelectors -> RdrName -> RnM Name
lookupGlobalOccRn' :: FieldsOrSelectors -> RdrName -> RnM Name
lookupGlobalOccRn' FieldsOrSelectors
fos RdrName
rdr_name =
  forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
lookupExactOrOrig RdrName
rdr_name forall a. a -> a
id forall a b. (a -> b) -> a -> b
$ do
    Maybe Name
mn <- FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
lookupGlobalOccRn_base FieldsOrSelectors
fos RdrName
rdr_name
    case Maybe Name
mn of
      Just Name
n -> forall (m :: * -> *) a. Monad m => a -> m a
return Name
n
      Maybe Name
Nothing -> do { String -> SDoc -> TcRn ()
traceRn String
"lookupGlobalOccRn" (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)
                    ; WhereLooking -> RdrName -> RnM Name
unboundName WhereLooking
WL_Global RdrName
rdr_name }

-- Looks up a RdrName occurrence in the GlobalRdrEnv and with
-- lookupQualifiedNameGHCi. Does not try to find an Exact or Orig name first.
-- lookupQualifiedNameGHCi here is used when we're in GHCi and a name like
-- 'Data.Map.elems' is typed, even if you didn't import Data.Map
lookupGlobalOccRn_base :: FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
lookupGlobalOccRn_base :: FieldsOrSelectors -> RdrName -> RnM (Maybe Name)
lookupGlobalOccRn_base FieldsOrSelectors
fos RdrName
rdr_name =
  forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
map forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT forall a b. (a -> b) -> a -> b
$
    [ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GlobalRdrElt -> Name
greMangledName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FieldsOrSelectors -> RdrName -> RnM (Maybe GlobalRdrElt)
lookupGreRn_maybe FieldsOrSelectors
fos RdrName
rdr_name
    , forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GreName -> Name
greNameMangledName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
lookupOneQualifiedNameGHCi FieldsOrSelectors
fos RdrName
rdr_name ]
                      -- This test is not expensive,
                      -- and only happens for failed lookups

lookupInfoOccRn :: RdrName -> RnM [Name]
-- lookupInfoOccRn is intended for use in GHCi's ":info" command
-- It finds all the GREs that RdrName could mean, not complaining
-- about ambiguity, but rather returning them all
-- C.f. #9881
-- lookupInfoOccRn is also used in situations where we check for
-- at least one definition of the RdrName, not complaining about
-- multiple definitions. (See #17832)
lookupInfoOccRn :: RdrName -> RnM [Name]
lookupInfoOccRn RdrName
rdr_name =
  forall r. RdrName -> (Name -> r) -> RnM r -> RnM r
lookupExactOrOrig RdrName
rdr_name (forall a. a -> [a] -> [a]
:[]) forall a b. (a -> b) -> a -> b
$
    do { GlobalRdrEnv
rdr_env <- TcRn GlobalRdrEnv
getGlobalRdrEnv
       ; let ns :: [Name]
ns = forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrElt -> Name
greMangledName (RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
lookupGRE_RdrName' RdrName
rdr_name GlobalRdrEnv
rdr_env)
       ; [Name]
qual_ns <- forall a b. (a -> b) -> [a] -> [b]
map GreName -> Name
greNameMangledName forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FieldsOrSelectors -> RdrName -> RnM [GreName]
lookupQualifiedNameGHCi FieldsOrSelectors
WantBoth RdrName
rdr_name
       ; forall (m :: * -> *) a. Monad m => a -> m a
return ([Name]
ns forall a. [a] -> [a] -> [a]
++ ([Name]
qual_ns forall a. Ord a => [a] -> [a] -> [a]
`minusList` [Name]
ns)) }

-- | Like 'lookupOccRn_maybe', but with a more informative result if
-- the 'RdrName' happens to be a record selector:
--
--   * Nothing                 -> name not in scope (no error reported)
--   * Just (UnambiguousGre x) -> name uniquely refers to x,
--                                or there is a name clash (reported)
--   * Just AmbiguousFields    -> name refers to two or more record fields
--                                (no error reported)
--
-- See Note [ Unbound vs Ambiguous Names ].
lookupGlobalOccRn_overloaded :: DuplicateRecordFields -> FieldsOrSelectors -> RdrName
                             -> RnM (Maybe AmbiguousResult)
lookupGlobalOccRn_overloaded :: DuplicateRecordFields
-> FieldsOrSelectors -> RdrName -> RnM (Maybe AmbiguousResult)
lookupGlobalOccRn_overloaded DuplicateRecordFields
dup_fields_ok FieldsOrSelectors
fos RdrName
rdr_name =
  forall r. RdrName -> (Maybe Name -> r) -> RnM r -> RnM r
lookupExactOrOrig_maybe RdrName
rdr_name (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (GreName -> AmbiguousResult
UnambiguousGre forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> GreName
NormalGreName)) forall a b. (a -> b) -> a -> b
$
    do { GreLookupResult
res <- FieldsOrSelectors -> RdrName -> RnM GreLookupResult
lookupGreRn_helper FieldsOrSelectors
fos RdrName
rdr_name
       ; case GreLookupResult
res of
           GreLookupResult
GreNotFound -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap GreName -> AmbiguousResult
UnambiguousGre forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
lookupOneQualifiedNameGHCi FieldsOrSelectors
fos RdrName
rdr_name
           OneNameMatch GlobalRdrElt
gre -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (GreName -> AmbiguousResult
UnambiguousGre (GlobalRdrElt -> GreName
gre_name GlobalRdrElt
gre))
           MultipleNames NonEmpty GlobalRdrElt
gres
             | forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all GlobalRdrElt -> Bool
isRecFldGRE NonEmpty GlobalRdrElt
gres
             , DuplicateRecordFields
dup_fields_ok forall a. Eq a => a -> a -> Bool
== DuplicateRecordFields
DuplicateRecordFields -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just AmbiguousResult
AmbiguousFields
             | Bool
otherwise -> do
                  RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
addNameClashErrRn RdrName
rdr_name NonEmpty GlobalRdrElt
gres
                  forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just (GreName -> AmbiguousResult
UnambiguousGre (GlobalRdrElt -> GreName
gre_name (forall a. NonEmpty a -> a
NE.head NonEmpty GlobalRdrElt
gres)))) }


-- | Result of looking up an occurrence that might be an ambiguous field.
data AmbiguousResult
    = UnambiguousGre GreName
    -- ^ Occurrence picked out a single name, which may or may not belong to a
    -- field (or might be unbound, if an error has been reported already, per
    -- Note [ Unbound vs Ambiguous Names ]).
    | AmbiguousFields
    -- ^ Occurrence picked out two or more fields, and no non-fields.  For now
    -- this is allowed by DuplicateRecordFields in certain circumstances, as the
    -- type-checker may be able to disambiguate later.


{-
Note [NoFieldSelectors]
~~~~~~~~~~~~~~~~~~~~~~~
The NoFieldSelectors extension allows record fields to be defined without
bringing the corresponding selector functions into scope.  However, such fields
may still be used in contexts such as record construction, pattern matching or
update. This requires us to distinguish contexts in which selectors are required
from those in which any field may be used.  For example:

  {-# LANGUAGE NoFieldSelectors #-}
  module M (T(foo), foo) where  -- T(foo) refers to the field,
                                -- unadorned foo to the value binding
    data T = MkT { foo :: Int }
    foo = ()

    bar = foo -- refers to the value binding, field ignored

  module N where
    import M (T(..))
    baz = MkT { foo = 3 } -- refers to the field
    oops = foo -- an error: the field is in scope but the value binding is not

Each 'FieldLabel' indicates (in the 'flHasFieldSelector' field) whether the
FieldSelectors extension was enabled in the defining module.  This allows them
to be filtered out by 'filterFieldGREs'.

Even when NoFieldSelectors is in use, we still generate selector functions
internally. For example, the expression
   getField @"foo" t
or (with dot-notation)
   t.foo
extracts the `foo` field of t::T, and hence needs the selector function
(see Note [HasField instances] in GHC.Tc.Instance.Class).  In order to avoid
name clashes with normal bindings reusing the names, selector names for such
fields are mangled just as for DuplicateRecordFields (see Note [FieldLabel] in
GHC.Types.FieldLabel).


In many of the name lookup functions in this module we pass a FieldsOrSelectors
value, indicating what we are looking for:

 * WantNormal: fields are in scope only if they have an accompanying selector
   function, e.g. we are looking up a variable in an expression
   (lookupExprOccRn).

 * WantBoth: any name or field will do, regardless of whether the selector
   function is available, e.g. record updates (lookupRecFieldOcc_update) with
   NoDisambiguateRecordFields.

 * WantField: any field will do, regardless of whether the selector function is
   available, but ignoring any non-field names, e.g. record updates
   (lookupRecFieldOcc_update) with DisambiguateRecordFields.

-----------------------------------------------------------------------------------
  Context                                  FieldsOrSelectors
-----------------------------------------------------------------------------------
  Record construction/pattern match        WantBoth if NoDisambiguateRecordFields
  e.g. MkT { foo = 3 }                     (DisambiguateRecordFields is separate)

  Record update                            WantBoth if NoDisambiguateRecordFields
  e.g. e { foo = 3 }                       WantField if DisambiguateRecordFields

  :info in GHCi                            WantBoth

  Variable occurrence in expression        WantNormal
  Type variable, data constructor
  Pretty much everything else
-----------------------------------------------------------------------------------
-}

-- | When looking up GREs, we may or may not want to include fields that were
-- defined in modules with @NoFieldSelectors@ enabled.  See Note
-- [NoFieldSelectors].
data FieldsOrSelectors
    = WantNormal -- ^ Include normal names, and fields with selectors, but
                 -- ignore fields without selectors.
    | WantBoth   -- ^ Include normal names and all fields (regardless of whether
                 -- they have selectors).
    | WantField  -- ^ Include only fields, with or without selectors, ignoring
                 -- any non-fields in scope.
  deriving FieldsOrSelectors -> FieldsOrSelectors -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
$c/= :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
== :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
$c== :: FieldsOrSelectors -> FieldsOrSelectors -> Bool
Eq

filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
filterFieldGREs FieldsOrSelectors
fos = forall a. (a -> Bool) -> [a] -> [a]
filter (FieldsOrSelectors -> GreName -> Bool
allowGreName FieldsOrSelectors
fos forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrElt -> GreName
gre_name)

allowGreName :: FieldsOrSelectors -> GreName -> Bool
allowGreName :: FieldsOrSelectors -> GreName -> Bool
allowGreName FieldsOrSelectors
WantBoth   GreName
_                 = Bool
True
allowGreName FieldsOrSelectors
WantNormal (FieldGreName FieldLabel
fl) = FieldLabel -> FieldSelectors
flHasFieldSelector FieldLabel
fl forall a. Eq a => a -> a -> Bool
== FieldSelectors
FieldSelectors
allowGreName FieldsOrSelectors
WantNormal (NormalGreName Name
_) = Bool
True
allowGreName FieldsOrSelectors
WantField  (FieldGreName  FieldLabel
_) = Bool
True
allowGreName FieldsOrSelectors
WantField  (NormalGreName Name
_) = Bool
False


--------------------------------------------------
--      Lookup in the Global RdrEnv of the module
--------------------------------------------------

data GreLookupResult = GreNotFound
                     | OneNameMatch GlobalRdrElt
                     | MultipleNames (NE.NonEmpty GlobalRdrElt)

lookupGreRn_maybe :: FieldsOrSelectors -> RdrName -> RnM (Maybe GlobalRdrElt)
-- Look up the RdrName in the GlobalRdrEnv
--   Exactly one binding: records it as "used", return (Just gre)
--   No bindings:         return Nothing
--   Many bindings:       report "ambiguous", return an arbitrary (Just gre)
-- Uses addUsedRdrName to record use and deprecations
lookupGreRn_maybe :: FieldsOrSelectors -> RdrName -> RnM (Maybe GlobalRdrElt)
lookupGreRn_maybe FieldsOrSelectors
fos RdrName
rdr_name
  = do
      GreLookupResult
res <- FieldsOrSelectors -> RdrName -> RnM GreLookupResult
lookupGreRn_helper FieldsOrSelectors
fos RdrName
rdr_name
      case GreLookupResult
res of
        OneNameMatch GlobalRdrElt
gre ->  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just GlobalRdrElt
gre
        MultipleNames NonEmpty GlobalRdrElt
gres -> do
          String -> SDoc -> TcRn ()
traceRn String
"lookupGreRn_maybe:NameClash" (forall a. Outputable a => a -> SDoc
ppr NonEmpty GlobalRdrElt
gres)
          RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
addNameClashErrRn RdrName
rdr_name NonEmpty GlobalRdrElt
gres
          forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (forall a. NonEmpty a -> a
NE.head NonEmpty GlobalRdrElt
gres)
        GreLookupResult
GreNotFound -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing

{-

Note [ Unbound vs Ambiguous Names ]

lookupGreRn_maybe deals with failures in two different ways. If a name
is unbound then we return a `Nothing` but if the name is ambiguous
then we raise an error and return a dummy name.

The reason for this is that when we call `lookupGreRn_maybe` we are
speculatively looking for whatever we are looking up. If we don't find it,
then we might have been looking for the wrong thing and can keep trying.
On the other hand, if we find a clash then there is no way to recover as
we found the thing we were looking for but can no longer resolve which
the correct one is.

One example of this is in `lookupTypeOccRn` which first looks in the type
constructor namespace before looking in the data constructor namespace to
deal with `DataKinds`.

There is however, as always, one exception to this scheme. If we find
an ambiguous occurrence of a record selector and DuplicateRecordFields
is enabled then we defer the selection until the typechecker.

-}




-- Internal Function
lookupGreRn_helper :: FieldsOrSelectors -> RdrName -> RnM GreLookupResult
lookupGreRn_helper :: FieldsOrSelectors -> RdrName -> RnM GreLookupResult
lookupGreRn_helper FieldsOrSelectors
fos RdrName
rdr_name
  = do  { GlobalRdrEnv
env <- TcRn GlobalRdrEnv
getGlobalRdrEnv
        ; case FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
filterFieldGREs FieldsOrSelectors
fos (RdrName -> GlobalRdrEnv -> [GlobalRdrElt]
lookupGRE_RdrName' RdrName
rdr_name GlobalRdrEnv
env) of
            []    -> forall (m :: * -> *) a. Monad m => a -> m a
return GreLookupResult
GreNotFound
            [GlobalRdrElt
gre] -> do { Bool -> GlobalRdrElt -> TcRn ()
addUsedGRE Bool
True GlobalRdrElt
gre
                        ; forall (m :: * -> *) a. Monad m => a -> m a
return (GlobalRdrElt -> GreLookupResult
OneNameMatch GlobalRdrElt
gre) }
            -- Don't record usage for ambiguous names
            -- until we know which is meant
            (GlobalRdrElt
gre:[GlobalRdrElt]
gres) -> forall (m :: * -> *) a. Monad m => a -> m a
return (NonEmpty GlobalRdrElt -> GreLookupResult
MultipleNames (GlobalRdrElt
gre forall a. a -> [a] -> NonEmpty a
NE.:| [GlobalRdrElt]
gres)) }

lookupGreAvailRn :: RdrName -> RnM (Name, AvailInfo)
-- Used in export lists
-- If not found or ambiguous, add error message, and fake with UnboundName
-- Uses addUsedRdrName to record use and deprecations
lookupGreAvailRn :: RdrName -> RnM (Name, AvailInfo)
lookupGreAvailRn RdrName
rdr_name
  = do
      GreLookupResult
mb_gre <- FieldsOrSelectors -> RdrName -> RnM GreLookupResult
lookupGreRn_helper FieldsOrSelectors
WantNormal RdrName
rdr_name
      case GreLookupResult
mb_gre of
        GreLookupResult
GreNotFound ->
          do
            String -> SDoc -> TcRn ()
traceRn String
"lookupGreAvailRn" (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)
            Name
name <- WhereLooking -> RdrName -> RnM Name
unboundName WhereLooking
WL_Global RdrName
rdr_name
            forall (m :: * -> *) a. Monad m => a -> m a
return (Name
name, Name -> AvailInfo
avail Name
name)
        MultipleNames NonEmpty GlobalRdrElt
gres ->
          do
            RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
addNameClashErrRn RdrName
rdr_name NonEmpty GlobalRdrElt
gres
            let unbound_name :: Name
unbound_name = RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name
            forall (m :: * -> *) a. Monad m => a -> m a
return (Name
unbound_name, Name -> AvailInfo
avail Name
unbound_name)
                        -- Returning an unbound name here prevents an error
                        -- cascade
        OneNameMatch GlobalRdrElt
gre ->
          forall (m :: * -> *) a. Monad m => a -> m a
return (GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre, GlobalRdrElt -> AvailInfo
availFromGRE GlobalRdrElt
gre)


{-
*********************************************************
*                                                      *
                Deprecations
*                                                      *
*********************************************************

Note [Handling of deprecations]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
* We report deprecations at each *occurrence* of the deprecated thing
  (see #5867)

* We do not report deprecations for locally-defined names. For a
  start, we may be exporting a deprecated thing. Also we may use a
  deprecated thing in the defn of another deprecated things.  We may
  even use a deprecated thing in the defn of a non-deprecated thing,
  when changing a module's interface.

* addUsedGREs: we do not report deprecations for sub-binders:
     - the ".." completion for records
     - the ".." in an export item 'T(..)'
     - the things exported by a module export 'module M'
-}

addUsedDataCons :: GlobalRdrEnv -> TyCon -> RnM ()
-- Remember use of in-scope data constructors (#7969)
addUsedDataCons :: GlobalRdrEnv -> TyCon -> TcRn ()
addUsedDataCons GlobalRdrEnv
rdr_env TyCon
tycon
  = [GlobalRdrElt] -> TcRn ()
addUsedGREs [ GlobalRdrElt
gre
                | DataCon
dc <- TyCon -> [DataCon]
tyConDataCons TyCon
tycon
                , Just GlobalRdrElt
gre <- [GlobalRdrEnv -> Name -> Maybe GlobalRdrElt
lookupGRE_Name GlobalRdrEnv
rdr_env (DataCon -> Name
dataConName DataCon
dc)] ]

addUsedGRE :: Bool -> GlobalRdrElt -> RnM ()
-- Called for both local and imported things
-- Add usage *and* warn if deprecated
addUsedGRE :: Bool -> GlobalRdrElt -> TcRn ()
addUsedGRE Bool
warn_if_deprec GlobalRdrElt
gre
  = do { forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
warn_if_deprec (GlobalRdrElt -> TcRn ()
warnIfDeprecated GlobalRdrElt
gre)
       ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (GlobalRdrElt -> Bool
isLocalGRE GlobalRdrElt
gre) forall a b. (a -> b) -> a -> b
$
         do { TcGblEnv
env <- forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv
            ; String -> SDoc -> TcRn ()
traceRn String
"addUsedGRE" (forall a. Outputable a => a -> SDoc
ppr GlobalRdrElt
gre)
            ; forall a env. IORef a -> (a -> a) -> IOEnv env ()
updMutVar (TcGblEnv -> TcRef [GlobalRdrElt]
tcg_used_gres TcGblEnv
env) (GlobalRdrElt
gre forall a. a -> [a] -> [a]
:) } }

addUsedGREs :: [GlobalRdrElt] -> RnM ()
-- Record uses of any *imported* GREs
-- Used for recording used sub-bndrs
-- NB: no call to warnIfDeprecated; see Note [Handling of deprecations]
addUsedGREs :: [GlobalRdrElt] -> TcRn ()
addUsedGREs [GlobalRdrElt]
gres
  | forall (t :: * -> *) a. Foldable t => t a -> Bool
null [GlobalRdrElt]
imp_gres = forall (m :: * -> *) a. Monad m => a -> m a
return ()
  | Bool
otherwise     = do { TcGblEnv
env <- forall gbl lcl. TcRnIf gbl lcl gbl
getGblEnv
                       ; String -> SDoc -> TcRn ()
traceRn String
"addUsedGREs" (forall a. Outputable a => a -> SDoc
ppr [GlobalRdrElt]
imp_gres)
                       ; forall a env. IORef a -> (a -> a) -> IOEnv env ()
updMutVar (TcGblEnv -> TcRef [GlobalRdrElt]
tcg_used_gres TcGblEnv
env) ([GlobalRdrElt]
imp_gres forall a. [a] -> [a] -> [a]
++) }
  where
    imp_gres :: [GlobalRdrElt]
imp_gres = forall a. (a -> Bool) -> [a] -> [a]
filterOut GlobalRdrElt -> Bool
isLocalGRE [GlobalRdrElt]
gres

warnIfDeprecated :: GlobalRdrElt -> RnM ()
warnIfDeprecated :: GlobalRdrElt -> TcRn ()
warnIfDeprecated gre :: GlobalRdrElt
gre@(GRE { gre_imp :: GlobalRdrElt -> [ImportSpec]
gre_imp = [ImportSpec]
iss })
  | (ImportSpec
imp_spec : [ImportSpec]
_) <- [ImportSpec]
iss
  = do { DynFlags
dflags <- forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
       ; Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
       ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (WarningFlag -> DynFlags -> Bool
wopt WarningFlag
Opt_WarnWarningsDeprecations DynFlags
dflags Bool -> Bool -> Bool
&&
               Bool -> Bool
not (Module -> Name -> Bool
nameIsLocalOrFrom Module
this_mod Name
name)) forall a b. (a -> b) -> a -> b
$
                   -- See Note [Handling of deprecations]
         do { ModIface
iface <- SDoc -> Name -> TcRn ModIface
loadInterfaceForName SDoc
doc Name
name
            ; case ModIface -> GlobalRdrElt -> Maybe WarningTxt
lookupImpDeprec ModIface
iface GlobalRdrElt
gre of
                Just WarningTxt
txt -> WarnReason -> SDoc -> TcRn ()
addWarn (WarningFlag -> WarnReason
Reason WarningFlag
Opt_WarnWarningsDeprecations)
                                   (ImportSpec -> WarningTxt -> SDoc
mk_msg ImportSpec
imp_spec WarningTxt
txt)
                Maybe WarningTxt
Nothing  -> forall (m :: * -> *) a. Monad m => a -> m a
return () } }
  | Bool
otherwise
  = forall (m :: * -> *) a. Monad m => a -> m a
return ()
  where
    occ :: OccName
occ = GlobalRdrElt -> OccName
greOccName GlobalRdrElt
gre
    name :: Name
name = GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre
    name_mod :: Module
name_mod = ASSERT2( isExternalName name, ppr name ) nameModule name
    doc :: SDoc
doc = String -> SDoc
text String
"The name" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr OccName
occ) SDoc -> SDoc -> SDoc
<+> PtrString -> SDoc
ptext (String -> PtrString
sLit String
"is mentioned explicitly")

    mk_msg :: ImportSpec -> WarningTxt -> SDoc
mk_msg ImportSpec
imp_spec WarningTxt
txt
      = [SDoc] -> SDoc
sep [ [SDoc] -> SDoc
sep [ String -> SDoc
text String
"In the use of"
                    SDoc -> SDoc -> SDoc
<+> NameSpace -> SDoc
pprNonVarNameSpace (OccName -> NameSpace
occNameSpace OccName
occ)
                    SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr OccName
occ)
                  , SDoc -> SDoc
parens SDoc
imp_msg SDoc -> SDoc -> SDoc
<> SDoc
colon ]
            , WarningTxt -> SDoc
pprWarningTxtForMsg WarningTxt
txt ]
      where
        imp_mod :: ModuleName
imp_mod  = ImportSpec -> ModuleName
importSpecModule ImportSpec
imp_spec
        imp_msg :: SDoc
imp_msg  = String -> SDoc
text String
"imported from" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr ModuleName
imp_mod SDoc -> SDoc -> SDoc
<> SDoc
extra
        extra :: SDoc
extra | ModuleName
imp_mod forall a. Eq a => a -> a -> Bool
== forall unit. GenModule unit -> ModuleName
moduleName Module
name_mod = SDoc
Outputable.empty
              | Bool
otherwise = String -> SDoc
text String
", but defined in" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr Module
name_mod

lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
lookupImpDeprec :: ModIface -> GlobalRdrElt -> Maybe WarningTxt
lookupImpDeprec ModIface
iface GlobalRdrElt
gre
  = ModIfaceBackend -> OccName -> Maybe WarningTxt
mi_warn_fn (forall (phase :: ModIfacePhase).
ModIface_ phase -> IfaceBackendExts phase
mi_final_exts ModIface
iface) (GlobalRdrElt -> OccName
greOccName GlobalRdrElt
gre) forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`  -- Bleat if the thing,
    case GlobalRdrElt -> Parent
gre_par GlobalRdrElt
gre of                      -- or its parent, is warn'd
       ParentIs  Name
p              -> ModIfaceBackend -> OccName -> Maybe WarningTxt
mi_warn_fn (forall (phase :: ModIfacePhase).
ModIface_ phase -> IfaceBackendExts phase
mi_final_exts ModIface
iface) (Name -> OccName
nameOccName Name
p)
       Parent
NoParent                 -> forall a. Maybe a
Nothing

{-
Note [Used names with interface not loaded]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
It's (just) possible to find a used
Name whose interface hasn't been loaded:

a) It might be a WiredInName; in that case we may not load
   its interface (although we could).

b) It might be GHC.Real.fromRational, or GHC.Num.fromInteger
   These are seen as "used" by the renamer (if -XRebindableSyntax)
   is on), but the typechecker may discard their uses
   if in fact the in-scope fromRational is GHC.Read.fromRational,
   (see tcPat.tcOverloadedLit), and the typechecker sees that the type
   is fixed, say, to GHC.Base.Float (see Inst.lookupSimpleInst).
   In that obscure case it won't force the interface in.

In both cases we simply don't permit deprecations;
this is, after all, wired-in stuff.


*********************************************************
*                                                      *
                GHCi support
*                                                      *
*********************************************************

A qualified name on the command line can refer to any module at
all: we try to load the interface if we don't already have it, just
as if there was an "import qualified M" declaration for every
module.

For example, writing `Data.List.sort` will load the interface file for
`Data.List` as if the user had written `import qualified Data.List`.

If we fail we just return Nothing, rather than bleating
about "attempting to use module ‘D’ (./D.hs) which is not loaded"
which is what loadSrcInterface does.

It is enabled by default and disabled by the flag
`-fno-implicit-import-qualified`.

Note [Safe Haskell and GHCi]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
We DON'T do this Safe Haskell as we need to check imports. We can
and should instead check the qualified import but at the moment
this requires some refactoring so leave as a TODO

Note [DuplicateRecordFields and -fimplicit-import-qualified]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
When DuplicateRecordFields is used, a single module can export the same OccName
multiple times, for example:

  module M where
    data S = MkS { foo :: Int }
    data T = MkT { foo :: Int }

Now if we refer to M.foo via -fimplicit-import-qualified, we need to report an
ambiguity error.

-}


-- | Like 'lookupQualifiedNameGHCi' but returning at most one name, reporting an
-- ambiguity error if there are more than one.
lookupOneQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
lookupOneQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM (Maybe GreName)
lookupOneQualifiedNameGHCi FieldsOrSelectors
fos RdrName
rdr_name = do
    [GreName]
gnames <- FieldsOrSelectors -> RdrName -> RnM [GreName]
lookupQualifiedNameGHCi FieldsOrSelectors
fos RdrName
rdr_name
    case [GreName]
gnames of
      []              -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
      [GreName
gname]         -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just GreName
gname)
      (GreName
gname:[GreName]
gnames') -> do RdrName -> NonEmpty GlobalRdrElt -> TcRn ()
addNameClashErrRn RdrName
rdr_name (GreName -> GlobalRdrElt
toGRE GreName
gname forall a. a -> [a] -> NonEmpty a
NE.:| forall a b. (a -> b) -> [a] -> [b]
map GreName -> GlobalRdrElt
toGRE [GreName]
gnames')
                            forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just (Name -> GreName
NormalGreName (RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name)))
  where
    -- Fake a GRE so we can report a sensible name clash error if
    -- -fimplicit-import-qualified is used with a module that exports the same
    -- field name multiple times (see
    -- Note [DuplicateRecordFields and -fimplicit-import-qualified]).
    toGRE :: GreName -> GlobalRdrElt
toGRE GreName
gname = GRE { gre_name :: GreName
gre_name = GreName
gname, gre_par :: Parent
gre_par = Parent
NoParent, gre_lcl :: Bool
gre_lcl = Bool
False, gre_imp :: [ImportSpec]
gre_imp = [ImportSpec
is] }
    is :: ImportSpec
is = ImpSpec { is_decl :: ImpDeclSpec
is_decl = ImpDeclSpec { is_mod :: ModuleName
is_mod = ModuleName
mod, is_as :: ModuleName
is_as = ModuleName
mod, is_qual :: Bool
is_qual = Bool
True, is_dloc :: SrcSpan
is_dloc = SrcSpan
noSrcSpan }
                 , is_item :: ImpItemSpec
is_item = ImpItemSpec
ImpAll }
    -- If -fimplicit-import-qualified succeeded, the name must be qualified.
    (ModuleName
mod, OccName
_) = forall a. a -> Maybe a -> a
fromMaybe (forall a. HasCallStack => String -> SDoc -> a
pprPanic String
"lookupOneQualifiedNameGHCi" (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)) (RdrName -> Maybe (ModuleName, OccName)
isQual_maybe RdrName
rdr_name)


-- | Look up *all* the names to which the 'RdrName' may refer in GHCi (using
-- @-fimplicit-import-qualified@).  This will normally be zero or one, but may
-- be more in the presence of @DuplicateRecordFields@.
lookupQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM [GreName]
lookupQualifiedNameGHCi :: FieldsOrSelectors -> RdrName -> RnM [GreName]
lookupQualifiedNameGHCi FieldsOrSelectors
fos RdrName
rdr_name
  = -- We want to behave as we would for a source file import here,
    -- and respect hiddenness of modules/packages, hence loadSrcInterface.
    do { DynFlags
dflags  <- forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
       ; Bool
is_ghci <- TcRn Bool
getIsGHCi
       ; DynFlags -> Bool -> RnM [GreName]
go_for_it DynFlags
dflags Bool
is_ghci }

  where
    go_for_it :: DynFlags -> Bool -> RnM [GreName]
go_for_it DynFlags
dflags Bool
is_ghci
      | Just (ModuleName
mod,OccName
occ) <- RdrName -> Maybe (ModuleName, OccName)
isQual_maybe RdrName
rdr_name
      , Bool
is_ghci
      , GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_ImplicitImportQualified DynFlags
dflags   -- Enables this GHCi behaviour
      , Bool -> Bool
not (DynFlags -> Bool
safeDirectImpsReq DynFlags
dflags)            -- See Note [Safe Haskell and GHCi]
      = do { MaybeErr SDoc ModIface
res <- SDoc
-> ModuleName
-> IsBootInterface
-> Maybe FastString
-> RnM (MaybeErr SDoc ModIface)
loadSrcInterface_maybe SDoc
doc ModuleName
mod IsBootInterface
NotBoot forall a. Maybe a
Nothing
           ; case MaybeErr SDoc ModIface
res of
                Succeeded ModIface
iface
                  -> forall (m :: * -> *) a. Monad m => a -> m a
return [ GreName
gname
                            | AvailInfo
avail <- forall (phase :: ModIfacePhase). ModIface_ phase -> [AvailInfo]
mi_exports ModIface
iface
                            , GreName
gname <- AvailInfo -> [GreName]
availGreNames AvailInfo
avail
                            , forall name. HasOccName name => name -> OccName
occName GreName
gname forall a. Eq a => a -> a -> Bool
== OccName
occ
                            -- Include a field if it has a selector or we are looking for all fields;
                            -- see Note [NoFieldSelectors].
                            , FieldsOrSelectors -> GreName -> Bool
allowGreName FieldsOrSelectors
fos GreName
gname
                            ]

                MaybeErr SDoc ModIface
_ -> -- Either we couldn't load the interface, or
                     -- we could but we didn't find the name in it
                     do { String -> SDoc -> TcRn ()
traceRn String
"lookupQualifiedNameGHCi" (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)
                        ; forall (m :: * -> *) a. Monad m => a -> m a
return [] } }

      | Bool
otherwise
      = do { String -> SDoc -> TcRn ()
traceRn String
"lookupQualifiedNameGHCi: off" (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)
           ; forall (m :: * -> *) a. Monad m => a -> m a
return [] }

    doc :: SDoc
doc = String -> SDoc
text String
"Need to find" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name

{-
Note [Looking up signature names]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
lookupSigOccRn is used for type signatures and pragmas
Is this valid?
  module A
        import M( f )
        f :: Int -> Int
        f x = x
It's clear that the 'f' in the signature must refer to A.f
The Haskell98 report does not stipulate this, but it will!
So we must treat the 'f' in the signature in the same way
as the binding occurrence of 'f', using lookupBndrRn

However, consider this case:
        import M( f )
        f :: Int -> Int
        g x = x
We don't want to say 'f' is out of scope; instead, we want to
return the imported 'f', so that later on the renamer will
correctly report "misplaced type sig".

Note [Signatures for top level things]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
data HsSigCtxt = ... | TopSigCtxt NameSet | ....

* The NameSet says what is bound in this group of bindings.
  We can't use isLocalGRE from the GlobalRdrEnv, because of this:
       f x = x
       $( ...some TH splice... )
       f :: Int -> Int
  When we encounter the signature for 'f', the binding for 'f'
  will be in the GlobalRdrEnv, and will be a LocalDef. Yet the
  signature is mis-placed

* For type signatures the NameSet should be the names bound by the
  value bindings; for fixity declarations, the NameSet should also
  include class sigs and record selectors

      infix 3 `f`          -- Yes, ok
      f :: C a => a -> a   -- No, not ok
      class C a where
        f :: a -> a
-}

data HsSigCtxt
  = TopSigCtxt NameSet       -- At top level, binding these names
                             -- See Note [Signatures for top level things]
  | LocalBindCtxt NameSet    -- In a local binding, binding these names
  | ClsDeclCtxt   Name       -- Class decl for this class
  | InstDeclCtxt  NameSet    -- Instance decl whose user-written method
                             -- bindings are for these methods
  | HsBootCtxt NameSet       -- Top level of a hs-boot file, binding these names
  | RoleAnnotCtxt NameSet    -- A role annotation, with the names of all types
                             -- in the group

instance Outputable HsSigCtxt where
    ppr :: HsSigCtxt -> SDoc
ppr (TopSigCtxt NameSet
ns) = String -> SDoc
text String
"TopSigCtxt" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr NameSet
ns
    ppr (LocalBindCtxt NameSet
ns) = String -> SDoc
text String
"LocalBindCtxt" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr NameSet
ns
    ppr (ClsDeclCtxt Name
n) = String -> SDoc
text String
"ClsDeclCtxt" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr Name
n
    ppr (InstDeclCtxt NameSet
ns) = String -> SDoc
text String
"InstDeclCtxt" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr NameSet
ns
    ppr (HsBootCtxt NameSet
ns) = String -> SDoc
text String
"HsBootCtxt" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr NameSet
ns
    ppr (RoleAnnotCtxt NameSet
ns) = String -> SDoc
text String
"RoleAnnotCtxt" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr NameSet
ns

lookupSigOccRn :: HsSigCtxt
               -> Sig GhcPs
               -> LocatedA RdrName -> RnM (LocatedA Name)
lookupSigOccRn :: HsSigCtxt -> Sig GhcPs -> LocatedA RdrName -> RnM (LocatedA Name)
lookupSigOccRn HsSigCtxt
ctxt Sig GhcPs
sig = HsSigCtxt -> SDoc -> LocatedA RdrName -> RnM (LocatedA Name)
lookupSigCtxtOccRn HsSigCtxt
ctxt (forall name. Sig name -> SDoc
hsSigDoc Sig GhcPs
sig)

lookupSigOccRnN :: HsSigCtxt
               -> Sig GhcPs
               -> LocatedN RdrName -> RnM (LocatedN Name)
lookupSigOccRnN :: HsSigCtxt -> Sig GhcPs -> LocatedN RdrName -> RnM (LocatedN Name)
lookupSigOccRnN HsSigCtxt
ctxt Sig GhcPs
sig = HsSigCtxt -> SDoc -> LocatedN RdrName -> RnM (LocatedN Name)
lookupSigCtxtOccRnN HsSigCtxt
ctxt (forall name. Sig name -> SDoc
hsSigDoc Sig GhcPs
sig)


-- | Lookup a name in relation to the names in a 'HsSigCtxt'
lookupSigCtxtOccRnN :: HsSigCtxt
                    -> SDoc         -- ^ description of thing we're looking up,
                                   -- like "type family"
                    -> LocatedN RdrName -> RnM (LocatedN Name)
lookupSigCtxtOccRnN :: HsSigCtxt -> SDoc -> LocatedN RdrName -> RnM (LocatedN Name)
lookupSigCtxtOccRnN HsSigCtxt
ctxt SDoc
what
  = forall a b ann.
(a -> TcM b)
-> GenLocated (SrcSpanAnn' ann) a
-> TcRn (GenLocated (SrcSpanAnn' ann) b)
wrapLocMA forall a b. (a -> b) -> a -> b
$ \ RdrName
rdr_name ->
    do { Either SDoc Name
mb_name <- HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
lookupBindGroupOcc HsSigCtxt
ctxt SDoc
what RdrName
rdr_name
       ; case Either SDoc Name
mb_name of
           Left SDoc
err   -> do { SDoc -> TcRn ()
addErr SDoc
err; forall (m :: * -> *) a. Monad m => a -> m a
return (RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name) }
           Right Name
name -> forall (m :: * -> *) a. Monad m => a -> m a
return Name
name }

-- | Lookup a name in relation to the names in a 'HsSigCtxt'
lookupSigCtxtOccRn :: HsSigCtxt
                   -> SDoc         -- ^ description of thing we're looking up,
                                   -- like "type family"
                   -> LocatedA RdrName -> RnM (LocatedA Name)
lookupSigCtxtOccRn :: HsSigCtxt -> SDoc -> LocatedA RdrName -> RnM (LocatedA Name)
lookupSigCtxtOccRn HsSigCtxt
ctxt SDoc
what
  = forall a b ann.
(a -> TcM b)
-> GenLocated (SrcSpanAnn' ann) a
-> TcRn (GenLocated (SrcSpanAnn' ann) b)
wrapLocMA forall a b. (a -> b) -> a -> b
$ \ RdrName
rdr_name ->
    do { Either SDoc Name
mb_name <- HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
lookupBindGroupOcc HsSigCtxt
ctxt SDoc
what RdrName
rdr_name
       ; case Either SDoc Name
mb_name of
           Left SDoc
err   -> do { SDoc -> TcRn ()
addErr SDoc
err; forall (m :: * -> *) a. Monad m => a -> m a
return (RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name) }
           Right Name
name -> forall (m :: * -> *) a. Monad m => a -> m a
return Name
name }

lookupBindGroupOcc :: HsSigCtxt
                   -> SDoc
                   -> RdrName -> RnM (Either SDoc Name)
-- Looks up the RdrName, expecting it to resolve to one of the
-- bound names passed in.  If not, return an appropriate error message
--
-- See Note [Looking up signature names]
lookupBindGroupOcc :: HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
lookupBindGroupOcc HsSigCtxt
ctxt SDoc
what RdrName
rdr_name
  | Just Name
n <- RdrName -> Maybe Name
isExact_maybe RdrName
rdr_name
  = Name -> RnM (Either SDoc Name)
lookupExactOcc_either Name
n   -- allow for the possibility of missing Exacts;
                              -- see Note [dataTcOccs and Exact Names]
      -- Maybe we should check the side conditions
      -- but it's a pain, and Exact things only show
      -- up when you know what you are doing

  | Just (Module
rdr_mod, OccName
rdr_occ) <- RdrName -> Maybe (Module, OccName)
isOrig_maybe RdrName
rdr_name
  = do { Name
n' <- forall a b. Module -> OccName -> TcRnIf a b Name
lookupOrig Module
rdr_mod OccName
rdr_occ
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right Name
n') }

  | Bool
otherwise
  = case HsSigCtxt
ctxt of
      HsBootCtxt NameSet
ns    -> (Name -> Bool) -> RnM (Either SDoc Name)
lookup_top (Name -> NameSet -> Bool
`elemNameSet` NameSet
ns)
      TopSigCtxt NameSet
ns    -> (Name -> Bool) -> RnM (Either SDoc Name)
lookup_top (Name -> NameSet -> Bool
`elemNameSet` NameSet
ns)
      RoleAnnotCtxt NameSet
ns -> (Name -> Bool) -> RnM (Either SDoc Name)
lookup_top (Name -> NameSet -> Bool
`elemNameSet` NameSet
ns)
      LocalBindCtxt NameSet
ns -> NameSet -> RnM (Either SDoc Name)
lookup_group NameSet
ns
      ClsDeclCtxt  Name
cls -> Name -> RnM (Either SDoc Name)
lookup_cls_op Name
cls
      InstDeclCtxt NameSet
ns  -> if forall a. (a -> Bool) -> UniqSet a -> Bool
uniqSetAny Name -> Bool
isUnboundName NameSet
ns -- #16610
                          then forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right forall a b. (a -> b) -> a -> b
$ RdrName -> Name
mkUnboundNameRdr RdrName
rdr_name)
                          else (Name -> Bool) -> RnM (Either SDoc Name)
lookup_top (Name -> NameSet -> Bool
`elemNameSet` NameSet
ns)
  where
    lookup_cls_op :: Name -> RnM (Either SDoc Name)
lookup_cls_op Name
cls
      = Bool -> Name -> SDoc -> RdrName -> RnM (Either SDoc Name)
lookupSubBndrOcc Bool
True Name
cls SDoc
doc RdrName
rdr_name
      where
        doc :: SDoc
doc = String -> SDoc
text String
"method of class" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr Name
cls)

    lookup_top :: (Name -> Bool) -> RnM (Either SDoc Name)
lookup_top Name -> Bool
keep_me
      = do { GlobalRdrEnv
env <- TcRn GlobalRdrEnv
getGlobalRdrEnv
           ; let all_gres :: [GlobalRdrElt]
all_gres = GlobalRdrEnv -> OccName -> [GlobalRdrElt]
lookupGlobalRdrEnv GlobalRdrEnv
env (RdrName -> OccName
rdrNameOcc RdrName
rdr_name)
                 names_in_scope :: [Name]
names_in_scope = -- If rdr_name lacks a binding, only
                                  -- recommend alternatives from related
                                  -- namespaces. See #17593.
                                  forall a. (a -> Bool) -> [a] -> [a]
filter (\Name
n -> NameSpace -> NameSpace -> Bool
nameSpacesRelated
                                                  (RdrName -> NameSpace
rdrNameSpace RdrName
rdr_name)
                                                  (Name -> NameSpace
nameNameSpace Name
n))
                                forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map GlobalRdrElt -> Name
greMangledName
                                forall a b. (a -> b) -> a -> b
$ forall a. (a -> Bool) -> [a] -> [a]
filter GlobalRdrElt -> Bool
isLocalGRE
                                forall a b. (a -> b) -> a -> b
$ GlobalRdrEnv -> [GlobalRdrElt]
globalRdrEnvElts GlobalRdrEnv
env
                 candidates_msg :: SDoc
candidates_msg = [Name] -> SDoc
candidates [Name]
names_in_scope
           ; case forall a. (a -> Bool) -> [a] -> [a]
filter (Name -> Bool
keep_me forall b c a. (b -> c) -> (a -> b) -> a -> c
. GlobalRdrElt -> Name
greMangledName) [GlobalRdrElt]
all_gres of
               [] | forall (t :: * -> *) a. Foldable t => t a -> Bool
null [GlobalRdrElt]
all_gres -> SDoc -> RnM (Either SDoc Name)
bale_out_with SDoc
candidates_msg
                  | Bool
otherwise     -> SDoc -> RnM (Either SDoc Name)
bale_out_with SDoc
local_msg
               (GlobalRdrElt
gre:[GlobalRdrElt]
_)            -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right (GlobalRdrElt -> Name
greMangledName GlobalRdrElt
gre)) }

    lookup_group :: NameSet -> RnM (Either SDoc Name)
lookup_group NameSet
bound_names  -- Look in the local envt (not top level)
      = do { Maybe Name
mname <- RdrName -> RnM (Maybe Name)
lookupLocalOccRn_maybe RdrName
rdr_name
           ; LocalRdrEnv
env <- RnM LocalRdrEnv
getLocalRdrEnv
           ; let candidates_msg :: SDoc
candidates_msg = [Name] -> SDoc
candidates forall a b. (a -> b) -> a -> b
$ LocalRdrEnv -> [Name]
localRdrEnvElts LocalRdrEnv
env
           ; case Maybe Name
mname of
               Just Name
n
                 | Name
n Name -> NameSet -> Bool
`elemNameSet` NameSet
bound_names -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. b -> Either a b
Right Name
n)
                 | Bool
otherwise                   -> SDoc -> RnM (Either SDoc Name)
bale_out_with SDoc
local_msg
               Maybe Name
Nothing                         -> SDoc -> RnM (Either SDoc Name)
bale_out_with SDoc
candidates_msg }

    bale_out_with :: SDoc -> RnM (Either SDoc Name)
bale_out_with SDoc
msg
        = forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. a -> Either a b
Left ([SDoc] -> SDoc
sep [ String -> SDoc
text String
"The" SDoc -> SDoc -> SDoc
<+> SDoc
what
                                SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"for" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name)
                           , Arity -> SDoc -> SDoc
nest Arity
2 forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"lacks an accompanying binding"]
                       SDoc -> SDoc -> SDoc
$$ Arity -> SDoc -> SDoc
nest Arity
2 SDoc
msg))

    local_msg :: SDoc
local_msg = SDoc -> SDoc
parens forall a b. (a -> b) -> a -> b
$ String -> SDoc
text String
"The"  SDoc -> SDoc -> SDoc
<+> SDoc
what SDoc -> SDoc -> SDoc
<+> PtrString -> SDoc
ptext (String -> PtrString
sLit String
"must be given where")
                           SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr RdrName
rdr_name) SDoc -> SDoc -> SDoc
<+> String -> SDoc
text String
"is declared"

    -- Identify all similar names and produce a message listing them
    candidates :: [Name] -> SDoc
    candidates :: [Name] -> SDoc
candidates [Name]
names_in_scope
      = case [Name]
similar_names of
          []  -> SDoc
Outputable.empty
          [Name
n] -> String -> SDoc
text String
"Perhaps you meant" SDoc -> SDoc -> SDoc
<+> Name -> SDoc
pp_item Name
n
          [Name]
_   -> [SDoc] -> SDoc
sep [ String -> SDoc
text String
"Perhaps you meant one of these:"
                     , Arity -> SDoc -> SDoc
nest Arity
2 (forall a. (a -> SDoc) -> [a] -> SDoc
pprWithCommas Name -> SDoc
pp_item [Name]
similar_names) ]
      where
        similar_names :: [Name]
similar_names
          = forall a. String -> [(String, a)] -> [a]
fuzzyLookup (FastString -> String
unpackFS forall a b. (a -> b) -> a -> b
$ OccName -> FastString
occNameFS forall a b. (a -> b) -> a -> b
$ RdrName -> OccName
rdrNameOcc RdrName
rdr_name)
                        forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (\Name
x -> ((FastString -> String
unpackFS forall a b. (a -> b) -> a -> b
$ OccName -> FastString
occNameFS forall a b. (a -> b) -> a -> b
$ Name -> OccName
nameOccName Name
x), Name
x))
                              [Name]
names_in_scope

        pp_item :: Name -> SDoc
pp_item Name
x = SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr Name
x) SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens (Name -> SDoc
pprDefinedAt Name
x)


---------------
lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [(RdrName, Name)]
-- GHC extension: look up both the tycon and data con or variable.
-- Used for top-level fixity signatures and deprecations.
-- Complain if neither is in scope.
-- See Note [Fixity signature lookup]
lookupLocalTcNames :: HsSigCtxt -> SDoc -> RdrName -> RnM [(RdrName, Name)]
lookupLocalTcNames HsSigCtxt
ctxt SDoc
what RdrName
rdr_name
  = do { [Either SDoc (RdrName, Name)]
mb_gres <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM RdrName
-> IOEnv (Env TcGblEnv TcLclEnv) (Either SDoc (RdrName, Name))
lookup (RdrName -> [RdrName]
dataTcOccs RdrName
rdr_name)
       ; let ([SDoc]
errs, [(RdrName, Name)]
names) = forall a b. [Either a b] -> ([a], [b])
partitionEithers [Either SDoc (RdrName, Name)]
mb_gres
       ; forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(RdrName, Name)]
names) forall a b. (a -> b) -> a -> b
$ SDoc -> TcRn ()
addErr (forall a. [a] -> a
head [SDoc]
errs) -- Bleat about one only
       ; forall (m :: * -> *) a. Monad m => a -> m a
return [(RdrName, Name)]
names }
  where
    lookup :: RdrName
-> IOEnv (Env TcGblEnv TcLclEnv) (Either SDoc (RdrName, Name))
lookup RdrName
rdr = do { Module
this_mod <- forall (m :: * -> *). HasModule m => m Module
getModule
                    ; Either SDoc Name
nameEither <- HsSigCtxt -> SDoc -> RdrName -> RnM (Either SDoc Name)
lookupBindGroupOcc HsSigCtxt
ctxt SDoc
what RdrName
rdr
                    ; forall (m :: * -> *) a. Monad m => a -> m a
return (Module
-> RdrName -> Either SDoc Name -> Either SDoc (RdrName, Name)
guard_builtin_syntax Module
this_mod RdrName
rdr Either SDoc Name
nameEither) }

    -- Guard against the built-in syntax (ex: `infixl 6 :`), see #15233
    guard_builtin_syntax :: Module
-> RdrName -> Either SDoc Name -> Either SDoc (RdrName, Name)
guard_builtin_syntax Module
this_mod RdrName
rdr (Right Name
name)
      | Just Name
_ <- OccName -> Maybe Name
isBuiltInOcc_maybe (forall name. HasOccName name => name -> OccName
occName RdrName
rdr)
      , Module
this_mod forall a. Eq a => a -> a -> Bool
/= HasDebugCallStack => Name -> Module
nameModule Name
name
      = forall a b. a -> Either a b
Left ([SDoc] -> SDoc
hsep [String -> SDoc
text String
"Illegal", SDoc
what, String -> SDoc
text String
"of built-in syntax:", forall a. Outputable a => a -> SDoc
ppr RdrName
rdr])
      | Bool
otherwise
      = forall a b. b -> Either a b
Right (RdrName
rdr, Name
name)
    guard_builtin_syntax Module
_ RdrName
_ (Left SDoc
err) = forall a b. a -> Either a b
Left SDoc
err

dataTcOccs :: RdrName -> [RdrName]
-- Return both the given name and the same name promoted to the TcClsName
-- namespace.  This is useful when we aren't sure which we are looking at.
-- See also Note [dataTcOccs and Exact Names]
dataTcOccs :: RdrName -> [RdrName]
dataTcOccs RdrName
rdr_name
  | OccName -> Bool
isDataOcc OccName
occ Bool -> Bool -> Bool
|| OccName -> Bool
isVarOcc OccName
occ
  = [RdrName
rdr_name, RdrName
rdr_name_tc]
  | Bool
otherwise
  = [RdrName
rdr_name]
  where
    occ :: OccName
occ = RdrName -> OccName
rdrNameOcc RdrName
rdr_name
    rdr_name_tc :: RdrName
rdr_name_tc =
      case RdrName
rdr_name of
        -- The (~) type operator is always in scope, so we need a special case
        -- for it here, or else  :info (~)  fails in GHCi.
        -- See Note [eqTyCon (~) is built-in syntax]
        Unqual OccName
occ | OccName -> FastString
occNameFS OccName
occ forall a. Eq a => a -> a -> Bool
== String -> FastString
fsLit String
"~" -> RdrName
eqTyCon_RDR
        RdrName
_ -> RdrName -> NameSpace -> RdrName
setRdrNameSpace RdrName
rdr_name NameSpace
tcName

{-
Note [dataTcOccs and Exact Names]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Exact RdrNames can occur in code generated by Template Haskell, and generally
those references are, well, exact. However, the TH `Name` type isn't expressive
enough to always track the correct namespace information, so we sometimes get
the right Unique but wrong namespace. Thus, we still have to do the double-lookup
for Exact RdrNames.

There is also an awkward situation for built-in syntax. Example in GHCi
   :info []
This parses as the Exact RdrName for nilDataCon, but we also want
the list type constructor.

Note that setRdrNameSpace on an Exact name requires the Name to be External,
which it always is for built in syntax.
-}



{-
************************************************************************
*                                                                      *
                        Rebindable names
        Dealing with rebindable syntax is driven by the
        Opt_RebindableSyntax dynamic flag.

        In "deriving" code we don't want to use rebindable syntax
        so we switch off the flag locally

*                                                                      *
************************************************************************

Haskell 98 says that when you say "3" you get the "fromInteger" from the
Standard Prelude, regardless of what is in scope.   However, to experiment
with having a language that is less coupled to the standard prelude, we're
trying a non-standard extension that instead gives you whatever "Prelude.fromInteger"
happens to be in scope.  Then you can
        import Prelude ()
        import MyPrelude as Prelude
to get the desired effect.

At the moment this just happens for
  * fromInteger, fromRational on literals (in expressions and patterns)
  * negate (in expressions)
  * minus  (arising from n+k patterns)
  * "do" notation

We store the relevant Name in the HsSyn tree, in
  * HsIntegral/HsFractional/HsIsString
  * NegApp
  * NPlusKPat
  * HsDo
respectively.  Initially, we just store the "standard" name (GHC.Builtin.Names.fromIntegralName,
fromRationalName etc), but the renamer changes this to the appropriate user
name if Opt_NoImplicitPrelude is on.  That is what lookupSyntax does.

We treat the original (standard) names as free-vars too, because the type checker
checks the type of the user thing against the type of the standard thing.
-}

lookupIfThenElse :: RnM (Maybe Name)
-- Looks up "ifThenElse" if rebindable syntax is on
lookupIfThenElse :: RnM (Maybe Name)
lookupIfThenElse
  = do { Bool
rebindable_on <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.RebindableSyntax
       ; if Bool -> Bool
not Bool
rebindable_on
         then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
         else do { Name
ite <- RdrName -> RnM Name
lookupOccRn (FastString -> RdrName
mkVarUnqual (String -> FastString
fsLit String
"ifThenElse"))
                 ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a. a -> Maybe a
Just Name
ite) } }

lookupSyntaxName :: Name                 -- ^ The standard name
                 -> RnM (Name, FreeVars) -- ^ Possibly a non-standard name
-- Lookup a Name that may be subject to Rebindable Syntax (RS).
--
-- - When RS is off, just return the supplied (standard) Name
--
-- - When RS is on, look up the OccName of the supplied Name; return
--   what we find, or the supplied Name if there is nothing in scope
lookupSyntaxName :: Name -> RnM (Name, NameSet)
lookupSyntaxName Name
std_name
  = do { Bool
rebind <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.RebindableSyntax
       ; if Bool -> Bool
not Bool
rebind
         then forall (m :: * -> *) a. Monad m => a -> m a
return (Name
std_name, NameSet
emptyFVs)
         else do { Name
nm <- RdrName -> RnM Name
lookupOccRn (OccName -> RdrName
mkRdrUnqual (Name -> OccName
nameOccName Name
std_name))
                 ; forall (m :: * -> *) a. Monad m => a -> m a
return (Name
nm, Name -> NameSet
unitFV Name
nm) } }

lookupSyntaxExpr :: Name                          -- ^ The standard name
                 -> RnM (HsExpr GhcRn, FreeVars)  -- ^ Possibly a non-standard name
lookupSyntaxExpr :: Name -> RnM (HsExpr GhcRn, NameSet)
lookupSyntaxExpr Name
std_name
  = do { (Name
name, NameSet
fvs) <- Name -> RnM (Name, NameSet)
lookupSyntaxName Name
std_name
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall (p :: Pass) a.
IsSrcSpanAnn p a =>
IdP (GhcPass p) -> HsExpr (GhcPass p)
nl_HsVar Name
name, NameSet
fvs) }

lookupSyntax :: Name                             -- The standard name
             -> RnM (SyntaxExpr GhcRn, FreeVars) -- Possibly a non-standard
                                                 -- name
lookupSyntax :: Name -> RnM (SyntaxExpr GhcRn, NameSet)
lookupSyntax Name
std_name
  = do { (HsExpr GhcRn
expr, NameSet
fvs) <- Name -> RnM (HsExpr GhcRn, NameSet)
lookupSyntaxExpr Name
std_name
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (HsExpr GhcRn -> SyntaxExprRn
mkSyntaxExpr HsExpr GhcRn
expr, NameSet
fvs) }

lookupSyntaxNames :: [Name]                         -- Standard names
     -> RnM ([HsExpr GhcRn], FreeVars) -- See comments with HsExpr.ReboundNames
   -- this works with CmdTop, which wants HsExprs, not SyntaxExprs
lookupSyntaxNames :: [Name] -> RnM ([HsExpr GhcRn], NameSet)
lookupSyntaxNames [Name]
std_names
  = do { Bool
rebindable_on <- forall gbl lcl. Extension -> TcRnIf gbl lcl Bool
xoptM Extension
LangExt.RebindableSyntax
       ; if Bool -> Bool
not Bool
rebindable_on then
             forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (a -> b) -> [a] -> [b]
map (forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
noExtField forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a an. a -> LocatedAn an a
noLocA) [Name]
std_names, NameSet
emptyFVs)
        else
          do { [Name]
usr_names <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (RdrName -> RnM Name
lookupOccRn forall b c a. (b -> c) -> (a -> b) -> a -> c
. OccName -> RdrName
mkRdrUnqual forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> OccName
nameOccName) [Name]
std_names
             ; forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. (a -> b) -> [a] -> [b]
map (forall p. XVar p -> LIdP p -> HsExpr p
HsVar NoExtField
noExtField forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a an. a -> LocatedAn an a
noLocA) [Name]
usr_names, [Name] -> NameSet
mkFVs [Name]
usr_names) } }


{-
Note [QualifiedDo]
~~~~~~~~~~~~~~~~~~
QualifiedDo is implemented using the same placeholders for operation names in
the AST that were devised for RebindableSyntax. Whenever the renamer checks
which names to use for do syntax, it first checks if the do block is qualified
(e.g. M.do { stmts }), in which case it searches for qualified names. If the
qualified names are not in scope, an error is produced. If the do block is not
qualified, the renamer does the usual search of the names which considers
whether RebindableSyntax is enabled or not. Dealing with QualifiedDo is driven
by the Opt_QualifiedDo dynamic flag.
-}

-- Lookup operations for a qualified do. If the context is not a qualified
-- do, then use lookupSyntaxExpr. See Note [QualifiedDo].
lookupQualifiedDoExpr :: HsStmtContext p -> Name -> RnM (HsExpr GhcRn, FreeVars)
lookupQualifiedDoExpr :: forall p. HsStmtContext p -> Name -> RnM (HsExpr GhcRn, NameSet)
lookupQualifiedDoExpr HsStmtContext p
ctxt Name
std_name
  = forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first forall (p :: Pass) a.
IsSrcSpanAnn p a =>
IdP (GhcPass p) -> HsExpr (GhcPass p)
nl_HsVar forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall p. HsStmtContext p -> Name -> RnM (Name, NameSet)
lookupQualifiedDoName HsStmtContext p
ctxt Name
std_name

-- Like lookupQualifiedDoExpr but for producing SyntaxExpr.
-- See Note [QualifiedDo].
lookupQualifiedDo
  :: HsStmtContext p
  -> Name
  -> RnM (SyntaxExpr GhcRn, FreeVars)
lookupQualifiedDo :: forall p.
HsStmtContext p -> Name -> RnM (SyntaxExpr GhcRn, NameSet)
lookupQualifiedDo HsStmtContext p
ctxt Name
std_name
  = forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first HsExpr GhcRn -> SyntaxExprRn
mkSyntaxExpr forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall p. HsStmtContext p -> Name -> RnM (HsExpr GhcRn, NameSet)
lookupQualifiedDoExpr HsStmtContext p
ctxt Name
std_name

lookupNameWithQualifier :: Name -> ModuleName -> RnM (Name, FreeVars)
lookupNameWithQualifier :: Name -> ModuleName -> RnM (Name, NameSet)
lookupNameWithQualifier Name
std_name ModuleName
modName
  = do { Name
qname <- RdrName -> RnM Name
lookupOccRn (ModuleName -> OccName -> RdrName
mkRdrQual ModuleName
modName (Name -> OccName
nameOccName Name
std_name))
       ; forall (m :: * -> *) a. Monad m => a -> m a
return (Name
qname, Name -> NameSet
unitFV Name
qname) }

-- See Note [QualifiedDo].
lookupQualifiedDoName
  :: HsStmtContext p
  -> Name
  -> RnM (Name, FreeVars)
lookupQualifiedDoName :: forall p. HsStmtContext p -> Name -> RnM (Name, NameSet)
lookupQualifiedDoName HsStmtContext p
ctxt Name
std_name
  = case forall p. HsStmtContext p -> Maybe ModuleName
qualifiedDoModuleName_maybe HsStmtContext p
ctxt of
      Maybe ModuleName
Nothing -> Name -> RnM (Name, NameSet)
lookupSyntaxName Name
std_name
      Just ModuleName
modName -> Name -> ModuleName -> RnM (Name, NameSet)
lookupNameWithQualifier Name
std_name ModuleName
modName


-- Error messages

opDeclErr :: RdrName -> SDoc
opDeclErr :: RdrName -> SDoc
opDeclErr RdrName
n
  = SDoc -> Arity -> SDoc -> SDoc
hang (String -> SDoc
text String
"Illegal declaration of a type or class operator" SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
quotes (forall a. Outputable a => a -> SDoc
ppr RdrName
n))
       Arity
2 (String -> SDoc
text String
"Use TypeOperators to declare operators in type and declarations")

badOrigBinding :: RdrName -> SDoc
badOrigBinding :: RdrName -> SDoc
badOrigBinding RdrName
name
  | Just Name
_ <- OccName -> Maybe Name
isBuiltInOcc_maybe OccName
occ
  = String -> SDoc
text String
"Illegal binding of built-in syntax:" SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr OccName
occ
    -- Use an OccName here because we don't want to print Prelude.(,)
  | Bool
otherwise
  = String -> SDoc
text String
"Cannot redefine a Name retrieved by a Template Haskell quote:"
    SDoc -> SDoc -> SDoc
<+> forall a. Outputable a => a -> SDoc
ppr RdrName
name
    -- This can happen when one tries to use a Template Haskell splice to
    -- define a top-level identifier with an already existing name, e.g.,
    --
    --   $(pure [ValD (VarP 'succ) (NormalB (ConE 'True)) []])
    --
    -- (See #13968.)
  where
    occ :: OccName
occ = RdrName -> OccName
rdrNameOcc forall a b. (a -> b) -> a -> b
$ RdrName -> RdrName
filterCTuple RdrName
name