GHC.Types.Name.Reader

GHC uses several kinds of name internally:

• OccName: see GHC.Types.Name.Occurrence
• RdrName is the type of names that come directly from the parser. They have not yet had their scoping and binding resolved by the renamer and can be thought of to a first approximation as an OccName with an optional module qualifier
• Name: see GHC.Types.Name
• Id: see GHC.Types.Id
• Var: see GHC.Types.Var

The main type

data RdrName

Reader Name

Do not use the data constructors of RdrName directly: prefer the family of functions that creates them, such as mkRdrUnqual

• Note: A Located RdrName will only have API Annotations if it is a compound one, e.g.

`bar`
( ~ )

• AnnKeywordId : AnnType, AnnOpen '(' or '[' or '[:', AnnClose ')' or ']' or ':]',, AnnBackquote '`', AnnVal AnnTilde,

Constructors

Unqual OccName

Unqualified name

Used for ordinary, unqualified occurrences, e.g. x, y or Foo. Create such a RdrName with mkRdrUnqual

Qual ModuleName OccName

Qualified name

A qualified name written by the user in source code. The module isn't necessarily the module where the thing is defined; just the one from which it is imported. Examples are Bar.x, Bar.y or Bar.Foo. Create such a RdrName with mkRdrQual

Orig Module OccName

Original name

An original name; the module is the defining module. This is used when GHC generates code that will be fed into the renamer (e.g. from deriving clauses), but where we want to say "Use Prelude.map dammit". One of these can be created with mkOrig

Exact Name

Exact name

We know exactly the Name. This is used:

1. When the parser parses built-in syntax like [] and (,), but wants a RdrName from it
2. By Template Haskell, when TH has generated a unique name

Such a RdrName can be created by using getRdrName on a Name

Instances

Data RdrName

Defined in GHC.Types.Name.Reader

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RdrName -> c RdrName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RdrName

toConstr :: RdrName -> Constr

dataTypeOf :: RdrName -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RdrName)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RdrName)

gmapT :: (forall b. Data b => b -> b) -> RdrName -> RdrName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RdrName -> r

gmapQ :: (forall d. Data d => d -> u) -> RdrName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> RdrName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RdrName -> m RdrName

DisambInfixOp RdrName

Defined in GHC.Parser.PostProcess

Methods

mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN RdrName)

mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN RdrName)

mkHsInfixHolePV :: SrcSpan -> (EpAnnComments -> EpAnn EpAnnUnboundVar) -> PV (Located RdrName)

HasOccName RdrName

Defined in GHC.Types.Name.Reader

Methods

occName :: RdrName -> OccName

Outputable RdrName

Defined in GHC.Types.Name.Reader

Methods

ppr :: RdrName -> SDoc

OutputableBndr RdrName

Defined in GHC.Types.Name.Reader

Methods

pprBndr :: BindingSite -> RdrName -> SDoc

pprPrefixOcc :: RdrName -> SDoc

pprInfixOcc :: RdrName -> SDoc

bndrIsJoin_maybe :: RdrName -> Maybe Int

Eq RdrName

Defined in GHC.Types.Name.Reader

Methods

(==) :: RdrName -> RdrName -> Bool

(/=) :: RdrName -> RdrName -> Bool

Ord RdrName

Defined in GHC.Types.Name.Reader

Methods

compare :: RdrName -> RdrName -> Ordering

(<) :: RdrName -> RdrName -> Bool

(<=) :: RdrName -> RdrName -> Bool

(>) :: RdrName -> RdrName -> Bool

(>=) :: RdrName -> RdrName -> Bool

max :: RdrName -> RdrName -> RdrName

min :: RdrName -> RdrName -> RdrName

type Anno RdrName

Defined in GHC.Hs.Extension

type Anno RdrName = SrcSpanAnnN

type Anno (LocatedN RdrName)

Defined in GHC.Hs.Binds

type Anno (LocatedN RdrName) = SrcSpan

type Anno [LocatedN RdrName]

Defined in GHC.Hs.Binds

type Anno [LocatedN RdrName] = SrcSpan

Construction

mkRdrUnqual :: OccName -> RdrName

mkRdrQual :: ModuleName -> OccName -> RdrName

mkUnqual :: NameSpace -> FastString -> RdrName

mkVarUnqual :: FastString -> RdrName

mkQual :: NameSpace -> (FastString, FastString) -> RdrName

Make a qualified RdrName in the given namespace and where the ModuleName and the OccName are taken from the first and second elements of the tuple respectively

mkOrig :: Module -> OccName -> RdrName

nameRdrName :: Name -> RdrName

getRdrName :: NamedThing thing => thing -> RdrName

Destruction

rdrNameOcc :: RdrName -> OccName

rdrNameSpace :: RdrName -> NameSpace

demoteRdrName :: RdrName -> Maybe RdrName

promoteRdrName :: RdrName -> Maybe RdrName

isRdrDataCon :: RdrName -> Bool

isRdrTyVar :: RdrName -> Bool

isRdrTc :: RdrName -> Bool

isQual :: RdrName -> Bool

isQual_maybe :: RdrName -> Maybe (ModuleName, OccName)

isUnqual :: RdrName -> Bool

isOrig :: RdrName -> Bool

isOrig_maybe :: RdrName -> Maybe (Module, OccName)

isExact :: RdrName -> Bool

isExact_maybe :: RdrName -> Maybe Name

isSrcRdrName :: RdrName -> Bool

Local mapping of RdrName to Name

data LocalRdrEnv

Local Reader Environment See Note [LocalRdrEnv]

Instances

Outputable LocalRdrEnv

Defined in GHC.Types.Name.Reader

Methods

ppr :: LocalRdrEnv -> SDoc

emptyLocalRdrEnv :: LocalRdrEnv

extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv

extendLocalRdrEnvList :: LocalRdrEnv -> [Name] -> LocalRdrEnv

lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name

lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name

elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool

inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool

localRdrEnvElts :: LocalRdrEnv -> [Name]

minusLocalRdrEnv :: LocalRdrEnv -> OccEnv a -> LocalRdrEnv

Global mapping of RdrName to GlobalRdrElts

type GlobalRdrEnv = OccEnv [GlobalRdrElt]

Global Reader Environment

Keyed by OccName; when looking up a qualified name we look up the OccName part, and then check the Provenance to see if the appropriate qualification is valid. This saves routinely doubling the size of the env by adding both qualified and unqualified names to the domain.

The list in the codomain is required because there may be name clashes These only get reported on lookup, not on construction

INVARIANT 1: All the members of the list have distinct gre_name fields; that is, no duplicate Names

INVARIANT 2: Imported provenance => Name is an ExternalName However LocalDefs can have an InternalName. This happens only when type-checking a [d| ... |] Template Haskell quotation; see this note in GHC.Rename.Names Note [Top-level Names in Template Haskell decl quotes]

INVARIANT 3: If the GlobalRdrEnv maps [occ -> gre], then greOccName gre = occ

NB: greOccName gre is usually the same as nameOccName (greMangledName gre), but not always in the case of record selectors; see Note [GreNames]

emptyGlobalRdrEnv :: GlobalRdrEnv

mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv

plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv

lookupGlobalRdrEnv :: GlobalRdrEnv -> OccName -> [GlobalRdrElt]

extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv

greOccName :: GlobalRdrElt -> OccName

See Note [GreNames]

shadowNames :: GlobalRdrEnv -> OccEnv a -> GlobalRdrEnv

pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc

globalRdrEnvElts :: GlobalRdrEnv -> [GlobalRdrElt]

lookupGRE_RdrName :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]

Look for this RdrName in the global environment. Omits record fields without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).

lookupGRE_RdrName' :: RdrName -> GlobalRdrEnv -> [GlobalRdrElt]

Look for this RdrName in the global environment. Includes record fields without selector functions (see Note [NoFieldSelectors] in GHC.Rename.Env).

lookupGRE_Name :: GlobalRdrEnv -> Name -> Maybe GlobalRdrElt

Look for precisely this Name in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same OccName.

lookupGRE_GreName :: GlobalRdrEnv -> GreName -> Maybe GlobalRdrElt

Look for precisely this GreName in the environment. This tests whether it is in scope, ignoring anything else that might be in scope with the same OccName.

lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe GlobalRdrElt

Look for a particular record field selector in the environment, where the selector name and field label may be different: the GlobalRdrEnv is keyed on the label. See Note [GreNames] for why this happens.

lookupGRE_Name_OccName :: GlobalRdrEnv -> Name -> OccName -> Maybe GlobalRdrElt

Look for precisely this Name in the environment, but with an OccName that might differ from that of the Name. See lookupGRE_FieldLabel and Note [GreNames].

getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]

transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv

Apply a transformation function to the GREs for these OccNames

pickGREs :: RdrName -> [GlobalRdrElt] -> [GlobalRdrElt]

Takes a list of GREs which have the right OccName x Pick those GREs that are in scope * Qualified, as x if want_qual is Qual M _ * Unqualified, as x if want_unqual is Unqual _

Return each such GRE, with its ImportSpecs filtered, to reflect how it is in scope qualified or unqualified respectively. See Note [GRE filtering]

pickGREsModExp :: ModuleName -> [GlobalRdrElt] -> [(GlobalRdrElt, GlobalRdrElt)]

Pick GREs that are in scope *both* qualified *and* unqualified Return each GRE that is, as a pair (qual_gre, unqual_gre) These two GREs are the original GRE with imports filtered to express how it is in scope qualified an unqualified respectively

Used only for the 'module M' item in export list; see exports_from_avail

GlobalRdrElts

gresFromAvails :: Maybe ImportSpec -> [AvailInfo] -> [GlobalRdrElt]

make a GlobalRdrEnv where all the elements point to the same Provenance (useful for "hiding" imports, or imports with no details).

gresFromAvail :: (Name -> Maybe ImportSpec) -> AvailInfo -> [GlobalRdrElt]

localGREsFromAvail :: AvailInfo -> [GlobalRdrElt]

availFromGRE :: GlobalRdrElt -> AvailInfo

greRdrNames :: GlobalRdrElt -> [RdrName]

greSrcSpan :: GlobalRdrElt -> SrcSpan

greQualModName :: GlobalRdrElt -> ModuleName

gresToAvailInfo :: [GlobalRdrElt] -> [AvailInfo]

Takes a list of distinct GREs and folds them into AvailInfos. This is more efficient than mapping each individual GRE to an AvailInfo and the folding using plusAvail but needs the uniqueness assumption.

greDefinitionModule :: GlobalRdrElt -> Maybe Module

The module in which the name pointed to by the GRE is defined.

greDefinitionSrcSpan :: GlobalRdrElt -> SrcSpan

The SrcSpan of the name pointed to by the GRE.

greMangledName :: GlobalRdrElt -> Name

A Name for the GRE for internal use. Careful: the OccName of this Name is not necessarily the same as the greOccName (see Note [GreNames]).

grePrintableName :: GlobalRdrElt -> Name

A Name for the GRE suitable for output to the user. Its OccName will be the greOccName (see Note [GreNames]).

greFieldLabel :: GlobalRdrElt -> Maybe FieldLabel

Returns the field label of this GRE, if it has one

Global RdrName mapping elements: GlobalRdrElt, Provenance, ImportSpec

data GlobalRdrElt

Global Reader Element

An element of the GlobalRdrEnv

Constructors

GRE

Fields

• gre_name :: !GreName

  See Note [GreNames]

• gre_par :: !Parent

  See Note [Parents]

• gre_lcl :: !Bool

  True = the thing was defined locally

• gre_imp :: !(Bag ImportSpec)

  In scope through these imports

Instances

Data GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GlobalRdrElt -> c GlobalRdrElt

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GlobalRdrElt

toConstr :: GlobalRdrElt -> Constr

dataTypeOf :: GlobalRdrElt -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GlobalRdrElt)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GlobalRdrElt)

gmapT :: (forall b. Data b => b -> b) -> GlobalRdrElt -> GlobalRdrElt

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GlobalRdrElt -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GlobalRdrElt -> r

gmapQ :: (forall d. Data d => d -> u) -> GlobalRdrElt -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GlobalRdrElt -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GlobalRdrElt -> m GlobalRdrElt

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GlobalRdrElt -> m GlobalRdrElt

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GlobalRdrElt -> m GlobalRdrElt

HasOccName GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

occName :: GlobalRdrElt -> OccName

Outputable GlobalRdrElt

Defined in GHC.Types.Name.Reader

Methods

ppr :: GlobalRdrElt -> SDoc

isLocalGRE :: GlobalRdrElt -> Bool

isRecFldGRE :: GlobalRdrElt -> Bool

isDuplicateRecFldGRE :: GlobalRdrElt -> Bool

Is this a record field defined with DuplicateRecordFields? (See Note [GreNames])

isNoFieldSelectorGRE :: GlobalRdrElt -> Bool

Is this a record field defined with NoFieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)

isFieldSelectorGRE :: GlobalRdrElt -> Bool

Is this a record field defined with FieldSelectors? (See Note [NoFieldSelectors] in GHC.Rename.Env)

unQualOK :: GlobalRdrElt -> Bool

Test if an unqualified version of this thing would be in scope

qualSpecOK :: ModuleName -> ImportSpec -> Bool

Is in scope qualified with the given module?

unQualSpecOK :: ImportSpec -> Bool

Is in scope unqualified?

pprNameProvenance :: GlobalRdrElt -> SDoc

Print out one place where the name was define/imported (With -dppr-debug, print them all)

data GreName

Used where we may have an ordinary name or a record field label. See Note [GreNames] in GHC.Types.Name.Reader.

Constructors

NormalGreName Name

FieldGreName FieldLabel

Instances

Data GreName

Defined in GHC.Types.Avail

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GreName -> c GreName

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GreName

toConstr :: GreName -> Constr

dataTypeOf :: GreName -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GreName)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GreName)

gmapT :: (forall b. Data b => b -> b) -> GreName -> GreName

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GreName -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GreName -> r

gmapQ :: (forall d. Data d => d -> u) -> GreName -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> GreName -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> GreName -> m GreName

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GreName -> m GreName

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GreName -> m GreName

HasOccName GreName

Defined in GHC.Types.Avail

Methods

occName :: GreName -> OccName

Binary GreName

Defined in GHC.Types.Avail

Methods

put_ :: BinHandle -> GreName -> IO ()

put :: BinHandle -> GreName -> IO (Bin GreName)

get :: BinHandle -> IO GreName

Outputable GreName

Defined in GHC.Types.Avail

Methods

ppr :: GreName -> SDoc

Eq GreName

Defined in GHC.Types.Avail

Methods

(==) :: GreName -> GreName -> Bool

(/=) :: GreName -> GreName -> Bool

greNameSrcSpan :: GreName -> SrcSpan

data Parent

See Note [Parents]

Constructors

NoParent

ParentIs

Fields

• par_is :: Name

Instances

Data Parent

Defined in GHC.Types.Name.Reader

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Parent -> c Parent

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Parent

toConstr :: Parent -> Constr

dataTypeOf :: Parent -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Parent)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Parent)

gmapT :: (forall b. Data b => b -> b) -> Parent -> Parent

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Parent -> r

gmapQ :: (forall d. Data d => d -> u) -> Parent -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Parent -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Parent -> m Parent

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Parent -> m Parent

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Parent -> m Parent

Outputable Parent

Defined in GHC.Types.Name.Reader

Methods

ppr :: Parent -> SDoc

Eq Parent

Defined in GHC.Types.Name.Reader

Methods

(==) :: Parent -> Parent -> Bool

(/=) :: Parent -> Parent -> Bool

greParent_maybe :: GlobalRdrElt -> Maybe Name

data ImportSpec

Import Specification

The ImportSpec of something says how it came to be imported It's quite elaborate so that we can give accurate unused-name warnings.

Constructors

ImpSpec

Fields

• is_decl :: ImpDeclSpec
• is_item :: ImpItemSpec

Instances

Data ImportSpec

Defined in GHC.Types.Name.Reader

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImportSpec -> c ImportSpec

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImportSpec

toConstr :: ImportSpec -> Constr

dataTypeOf :: ImportSpec -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImportSpec)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImportSpec)

gmapT :: (forall b. Data b => b -> b) -> ImportSpec -> ImportSpec

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImportSpec -> r

gmapQ :: (forall d. Data d => d -> u) -> ImportSpec -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImportSpec -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImportSpec -> m ImportSpec

Outputable ImportSpec

Defined in GHC.Types.Name.Reader

Methods

ppr :: ImportSpec -> SDoc

Eq ImportSpec

Defined in GHC.Types.Name.Reader

Methods

(==) :: ImportSpec -> ImportSpec -> Bool

(/=) :: ImportSpec -> ImportSpec -> Bool

data ImpDeclSpec

Import Declaration Specification

Describes a particular import declaration and is shared among all the Provenances for that decl

Constructors

ImpDeclSpec

Fields

• is_mod :: ModuleName

  Module imported, e.g. import Muggle Note the Muggle may well not be the defining module for this thing!

• is_as :: ModuleName

  Import alias, e.g. from as M (or Muggle if there is no as clause)

• is_qual :: Bool

  Was this import qualified?

• is_dloc :: SrcSpan

  The location of the entire import declaration

Instances

Data ImpDeclSpec

Defined in GHC.Types.Name.Reader

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImpDeclSpec -> c ImpDeclSpec

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImpDeclSpec

toConstr :: ImpDeclSpec -> Constr

dataTypeOf :: ImpDeclSpec -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImpDeclSpec)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImpDeclSpec)

gmapT :: (forall b. Data b => b -> b) -> ImpDeclSpec -> ImpDeclSpec

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImpDeclSpec -> r

gmapQ :: (forall d. Data d => d -> u) -> ImpDeclSpec -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImpDeclSpec -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpDeclSpec -> m ImpDeclSpec

Eq ImpDeclSpec

Defined in GHC.Types.Name.Reader

Methods

(==) :: ImpDeclSpec -> ImpDeclSpec -> Bool

(/=) :: ImpDeclSpec -> ImpDeclSpec -> Bool

data ImpItemSpec

Import Item Specification

Describes import info a particular Name

Constructors

ImpAll

The import had no import list, or had a hiding list

ImpSome

The import had an import list. The is_explicit field is True iff the thing was named explicitly in the import specs rather than being imported as part of a "..." group. Consider:

import C( T(..) )

Here the constructors of T are not named explicitly; only T is named explicitly.

Fields

• is_explicit :: Bool
• is_iloc :: SrcSpan

Instances

Data ImpItemSpec

Defined in GHC.Types.Name.Reader

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ImpItemSpec -> c ImpItemSpec

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ImpItemSpec

toConstr :: ImpItemSpec -> Constr

dataTypeOf :: ImpItemSpec -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ImpItemSpec)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ImpItemSpec)

gmapT :: (forall b. Data b => b -> b) -> ImpItemSpec -> ImpItemSpec

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ImpItemSpec -> r

gmapQ :: (forall d. Data d => d -> u) -> ImpItemSpec -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> ImpItemSpec -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ImpItemSpec -> m ImpItemSpec

Eq ImpItemSpec

Defined in GHC.Types.Name.Reader

Methods

(==) :: ImpItemSpec -> ImpItemSpec -> Bool

(/=) :: ImpItemSpec -> ImpItemSpec -> Bool

importSpecLoc :: ImportSpec -> SrcSpan

importSpecModule :: ImportSpec -> ModuleName

isExplicitItem :: ImpItemSpec -> Bool

bestImport :: [ImportSpec] -> ImportSpec

Utils

opIsAt :: RdrName -> Bool

Indicate if the given name is the "@" operator