Safe Haskell	None
Language	GHC2021

GHC.Types.Name.Reader

Contents

The main type
- Construction
- Destruction
Local mapping of RdrName to Name
Global mapping of RdrName to GlobalRdrElts
- Looking up GlobalRdrElts
GlobalRdrElts
Utils

Description

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

Synopsis

data RdrName
- = Unqual OccName
- | Qual ModuleName OccName
- | Orig Module OccName
- | Exact Name
mkRdrUnqual :: OccName -> RdrName
mkRdrQual :: ModuleName -> OccName -> RdrName
mkUnqual :: NameSpace -> FastString -> RdrName
mkVarUnqual :: FastString -> RdrName
mkQual :: NameSpace -> (FastString, FastString) -> RdrName
mkOrig :: Module -> OccName -> RdrName
nameRdrName :: Name -> RdrName
getRdrName :: NamedThing thing => thing -> RdrName
rdrNameOcc :: RdrName -> OccName
rdrNameSpace :: RdrName -> NameSpace
demoteRdrName :: RdrName -> Maybe RdrName
demoteRdrNameTv :: 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
data LocalRdrEnv
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
minusLocalRdrEnvList :: LocalRdrEnv -> [OccName] -> LocalRdrEnv
type GlobalRdrEnvX info = OccEnv [GlobalRdrEltX info]
type GlobalRdrEnv = GlobalRdrEnvX GREInfo
type IfGlobalRdrEnv = GlobalRdrEnvX ()
emptyGlobalRdrEnv :: GlobalRdrEnvX info
mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv
plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv
greOccName :: GlobalRdrEltX info -> OccName
pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc
globalRdrEnvElts :: GlobalRdrEnvX info -> [GlobalRdrEltX info]
globalRdrEnvLocal :: GlobalRdrEnvX info -> GlobalRdrEnvX info
data FieldsOrSelectors
- = WantNormal
- | WantBoth
- | WantField
filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt]
allowGRE :: FieldsOrSelectors -> GlobalRdrElt -> Bool
data LookupGRE info where
- LookupOccName :: forall info. OccName -> WhichGREs info -> LookupGRE info
- LookupRdrName :: forall info. RdrName -> WhichGREs info -> LookupGRE info
- LookupExactName :: forall info. {..} -> LookupGRE info
- LookupChildren :: forall info. OccName -> LookupChild -> LookupGRE info
lookupGRE :: GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info]
data WhichGREs info where
- SameNameSpace :: forall info. WhichGREs info
- RelevantGREs :: {..} -> WhichGREs GREInfo
- pattern AllRelevantGREs :: WhichGREs GREInfo
- pattern RelevantGREsFOS :: FieldsOrSelectors -> WhichGREs GREInfo
greIsRelevant :: WhichGREs GREInfo -> NameSpace -> GlobalRdrElt -> Bool
data LookupChild = LookupChild {
- wantedParent :: Name
- lookupDataConFirst :: Bool
- prioritiseParent :: Bool
}
lookupGRE_Name :: Outputable info => GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info)
lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe FieldGlobalRdrElt
getGRE_NameQualifier_maybes :: GlobalRdrEnv -> Name -> [Maybe [ModuleName]]
transformGREs :: (GlobalRdrElt -> GlobalRdrElt) -> [OccName] -> GlobalRdrEnv -> GlobalRdrEnv
pickGREs :: RdrName -> [GlobalRdrEltX info] -> [GlobalRdrEltX info]
pickGREsModExp :: ModuleName -> [GlobalRdrEltX info] -> [(GlobalRdrEltX info, GlobalRdrEltX info)]
availFromGRE :: GlobalRdrEltX info -> AvailInfo
greRdrNames :: GlobalRdrEltX info -> [RdrName]
greSrcSpan :: Outputable info => GlobalRdrEltX info -> SrcSpan
greQualModName :: Outputable info => GlobalRdrEltX info -> ModuleName
gresToAvailInfo :: [GlobalRdrEltX info] -> [AvailInfo]
greDefinitionModule :: GlobalRdrEltX info -> Maybe Module
greDefinitionSrcSpan :: GlobalRdrEltX info -> SrcSpan
greFieldLabel_maybe :: GlobalRdrElt -> Maybe FieldLabel
data GlobalRdrEltX info = GRE {
- gre_name :: !Name
- gre_par :: !Parent
- gre_lcl :: !Bool
- gre_imp :: !(Bag ImportSpec)
- gre_info :: info
}
type GlobalRdrElt = GlobalRdrEltX GREInfo
type IfGlobalRdrElt = GlobalRdrEltX ()
type FieldGlobalRdrElt = GlobalRdrElt
greName :: GlobalRdrEltX info -> Name
greNameSpace :: GlobalRdrEltX info -> NameSpace
greParent :: GlobalRdrEltX info -> Parent
greInfo :: GlobalRdrElt -> GREInfo
plusGRE :: GlobalRdrElt -> GlobalRdrElt -> GlobalRdrElt
insertGRE :: GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt]
forceGlobalRdrEnv :: GlobalRdrEnvX info -> IfGlobalRdrEnv
hydrateGlobalRdrEnv :: (Name -> IO info) -> GlobalRdrEnvX noInfo -> GlobalRdrEnvX info
isLocalGRE :: GlobalRdrEltX info -> Bool
isImportedGRE :: GlobalRdrEltX info -> Bool
isRecFldGRE :: GlobalRdrEltX info -> Bool
fieldGREInfo :: HasDebugCallStack => FieldGlobalRdrElt -> RecFieldInfo
isDuplicateRecFldGRE :: GlobalRdrElt -> Bool
isNoFieldSelectorGRE :: GlobalRdrElt -> Bool
isFieldSelectorGRE :: GlobalRdrElt -> Bool
unQualOK :: GlobalRdrEltX info -> Bool
qualSpecOK :: ModuleName -> ImportSpec -> Bool
unQualSpecOK :: ImportSpec -> Bool
pprNameProvenance :: GlobalRdrEltX info -> SDoc
mkGRE :: (Name -> Maybe ImportSpec) -> GREInfo -> Parent -> Name -> GlobalRdrElt
mkExactGRE :: Name -> GREInfo -> GlobalRdrElt
mkLocalGRE :: GREInfo -> Parent -> Name -> GlobalRdrElt
mkLocalVanillaGRE :: Parent -> Name -> GlobalRdrElt
mkLocalTyConGRE :: TyConFlavour Name -> Name -> GlobalRdrElt
mkLocalConLikeGRE :: Parent -> (ConLikeName, ConInfo) -> GlobalRdrElt
mkLocalFieldGREs :: Parent -> [(ConLikeName, ConInfo)] -> [GlobalRdrElt]
gresToNameSet :: [GlobalRdrEltX info] -> NameSet
greClashesWith :: GlobalRdrElt -> GlobalRdrElt -> Bool
shadowNames :: Bool -> GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv
data ConLikeName
- = DataConName {
  - conLikeName_Name :: !Name
  }
- | PatSynName {
  - conLikeName_Name :: !Name
  }
data GREInfo
- = Vanilla
- | UnboundGRE
- | IAmTyCon !(TyConFlavour Name)
- | IAmConLike !ConInfo
- | IAmRecField !RecFieldInfo
data RecFieldInfo = RecFieldInfo {
- recFieldLabel :: !FieldLabel
- recFieldCons :: !(UniqSet ConLikeName)
}
plusGREInfo :: GREInfo -> GREInfo -> GREInfo
recFieldConLike_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe ConInfo
recFieldInfo_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe RecFieldInfo
fieldGRE_maybe :: GlobalRdrElt -> Maybe FieldGlobalRdrElt
fieldGRELabel :: HasDebugCallStack => FieldGlobalRdrElt -> FieldLabel
data Parent
- = NoParent
- | ParentIs {
  - par_is :: !Name
  }
greParent_maybe :: GlobalRdrEltX info -> Maybe Name
mkParent :: Name -> AvailInfo -> Parent
availParent :: AvailInfo -> Parent
data ImportSpec = ImpSpec {
- is_decl :: !ImpDeclSpec
- is_item :: !ImpItemSpec
}
data ImpDeclSpec = ImpDeclSpec {
- is_mod :: !Module
- is_as :: !ModuleName
- is_pkg_qual :: !PkgQual
- is_qual :: !Bool
- is_dloc :: !SrcSpan
- is_isboot :: !IsBootInterface
}
data ImpItemSpec
- = ImpAll
- | ImpSome {
  - is_explicit :: !Bool
  - is_iloc :: !SrcSpan
  }
importSpecLoc :: ImportSpec -> SrcSpan
importSpecModule :: ImportSpec -> ModuleName
isExplicitItem :: ImpItemSpec -> Bool
bestImport :: NonEmpty ImportSpec -> ImportSpec
opIsAt :: RdrName -> Bool

The main type

data RdrName Source #

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: When the parser parses built-in syntax like `[]` and `(,)`, but wants a `RdrName` from it By Template Haskell, when TH has generated a unique name Such a `RdrName` can be created by using `getRdrName` on a `Name`

Instances

Instances details

DisambInfixOp RdrName Source #
Instance details Defined in GHC.Parser.PostProcess Methods mkHsVarOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) Source # mkHsConOpPV :: LocatedN RdrName -> PV (LocatedN RdrName) Source # mkHsInfixHolePV :: LocatedN (HsExpr GhcPs) -> PV (LocatedN RdrName) Source #
HasOccName RdrName Source #
Instance details Defined in GHC.Types.Name.Reader Methods occName :: RdrName -> OccName Source #
Outputable RdrName Source #
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: RdrName -> SDoc Source #
OutputableBndr RdrName Source #
Instance details Defined in GHC.Types.Name.Reader Methods pprBndr :: BindingSite -> RdrName -> SDoc Source # pprPrefixOcc :: RdrName -> SDoc Source # pprInfixOcc :: RdrName -> SDoc Source # bndrIsJoin_maybe :: RdrName -> JoinPointHood Source #
Data RdrName Source #
Instance details 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 #
Eq RdrName Source #
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: RdrName -> RdrName -> Bool # (/=) :: RdrName -> RdrName -> Bool #
Ord RdrName Source #
Instance details 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 Source #
Instance details Defined in GHC.Hs.Extension type Anno RdrName = SrcSpanAnnN

Construction

mkRdrUnqual :: OccName -> RdrName Source #

mkRdrQual :: ModuleName -> OccName -> RdrName Source #

mkUnqual :: NameSpace -> FastString -> RdrName Source #

mkVarUnqual :: FastString -> RdrName Source #

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

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 Source #

nameRdrName :: Name -> RdrName Source #

getRdrName :: NamedThing thing => thing -> RdrName Source #

Destruction

rdrNameOcc :: RdrName -> OccName Source #

rdrNameSpace :: RdrName -> NameSpace Source #

demoteRdrName :: RdrName -> Maybe RdrName Source #

demoteRdrNameTv :: RdrName -> Maybe RdrName Source #

promoteRdrName :: RdrName -> Maybe RdrName Source #

isRdrDataCon :: RdrName -> Bool Source #

isRdrTyVar :: RdrName -> Bool Source #

isRdrTc :: RdrName -> Bool Source #

isQual :: RdrName -> Bool Source #

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

isUnqual :: RdrName -> Bool Source #

isOrig :: RdrName -> Bool Source #

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

isExact :: RdrName -> Bool Source #

isExact_maybe :: RdrName -> Maybe Name Source #

isSrcRdrName :: RdrName -> Bool Source #

Local mapping of `RdrName` to `Name`

data LocalRdrEnv Source #

Local Reader Environment See Note [LocalRdrEnv]

Instances

Instances details

Outputable LocalRdrEnv Source #
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: LocalRdrEnv -> SDoc Source #

emptyLocalRdrEnv :: LocalRdrEnv Source #

extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv Source #

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

lookupLocalRdrEnv :: LocalRdrEnv -> RdrName -> Maybe Name Source #

lookupLocalRdrOcc :: LocalRdrEnv -> OccName -> Maybe Name Source #

elemLocalRdrEnv :: RdrName -> LocalRdrEnv -> Bool Source #

inLocalRdrEnvScope :: Name -> LocalRdrEnv -> Bool Source #

localRdrEnvElts :: LocalRdrEnv -> [Name] Source #

minusLocalRdrEnv :: LocalRdrEnv -> OccEnv a -> LocalRdrEnv Source #

minusLocalRdrEnvList :: LocalRdrEnv -> [OccName] -> LocalRdrEnv Source #

Global mapping of `RdrName` to `GlobalRdrElt`s

type GlobalRdrEnvX info = OccEnv [GlobalRdrEltX info] Source #

Parametrises GlobalRdrEnv over the presence or absence of GREInfo.

See Note [IfGlobalRdrEnv].

type GlobalRdrEnv = GlobalRdrEnvX GREInfo Source #

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

type IfGlobalRdrEnv = GlobalRdrEnvX () Source #

A GlobalRdrEnv in which the GlobalRdrElts don't have any GREInfo attached to them. This is useful to avoid space leaks, see Note [IfGlobalRdrEnv].

emptyGlobalRdrEnv :: GlobalRdrEnvX info Source #

mkGlobalRdrEnv :: [GlobalRdrElt] -> GlobalRdrEnv Source #

plusGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrEnv -> GlobalRdrEnv Source #

extendGlobalRdrEnv :: GlobalRdrEnv -> GlobalRdrElt -> GlobalRdrEnv Source #

greOccName :: GlobalRdrEltX info -> OccName Source #

pprGlobalRdrEnv :: Bool -> GlobalRdrEnv -> SDoc Source #

globalRdrEnvElts :: GlobalRdrEnvX info -> [GlobalRdrEltX info] Source #

globalRdrEnvLocal :: GlobalRdrEnvX info -> GlobalRdrEnvX info Source #

Looking up `GlobalRdrElt`s

data FieldsOrSelectors Source #

When looking up GREs, we may or may not want to include fields that were defined in modules with NoFieldSelectors enabled. See Note [NoFieldSelectors].

Constructors

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.

Instances

Instances details

Show FieldsOrSelectors Source #
Instance details Defined in GHC.Types.Name.Reader Methods showsPrec :: Int -> FieldsOrSelectors -> ShowS # show :: FieldsOrSelectors -> String # showList :: [FieldsOrSelectors] -> ShowS #
Eq FieldsOrSelectors Source #
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: FieldsOrSelectors -> FieldsOrSelectors -> Bool # (/=) :: FieldsOrSelectors -> FieldsOrSelectors -> Bool #

filterFieldGREs :: FieldsOrSelectors -> [GlobalRdrElt] -> [GlobalRdrElt] Source #

allowGRE :: FieldsOrSelectors -> GlobalRdrElt -> Bool Source #

data LookupGRE info where Source #

What should we look up in a GlobalRdrEnv? Should we only look up names with the exact same OccName, or do we allow different NameSpaces?

Depending on the answer, we might need more or less information from the GlobalRdrEnv, e.g. if we want to include matching record fields we need to know if the corresponding record fields define field selectors, for which we need to consult the GREInfo. This is why this datatype is a GADT.

See Note [IfGlobalRdrEnv].

Constructors

LookupOccName	Look for this specific `OccName`, with the exact same `NameSpace`, in the `GlobalRdrEnv`.
Fields :: forall info. OccName the `OccName` to look up -> WhichGREs info information about other relevant `NameSpace`s -> LookupGRE info
LookupRdrName	Look up the `OccName` of this `RdrName` in the `GlobalRdrEnv`, filtering out those whose qualification matches that of the `RdrName`. Lookup returns an empty result for `Exact` or `Orig` `RdrName`s.
Fields :: forall info. RdrName the `RdrName` to look up -> WhichGREs info information about other relevant `NameSpace`s -> LookupGRE info
LookupExactName	Look for `GRE`s with the same unique as the given `Name` in the `GlobalRdrEnv`.
Fields :: forall info. { lookupExactName :: Name the `Name` to look up , lookInAllNameSpaces :: Bool whether to look in all `NameSpace`s, or just in the `NameSpace` of the `Name` See Note [Template Haskell ambiguity] } -> LookupGRE info
LookupChildren	Look up children `GlobalRdrElt`s with a given `Parent`.
Fields :: forall info. OccName the `OccName` to look up -> LookupChild information to decide which `GlobalRdrElt`s are valid children after looking up -> LookupGRE info

lookupGRE :: GlobalRdrEnvX info -> LookupGRE info -> [GlobalRdrEltX info] Source #

Look something up in the Global Reader Environment.

The LookupGRE argument specifies what to look up, and in particular whether there should there be any lee-way if the NameSpaces don't exactly match.

data WhichGREs info where Source #

How should we look up in a GlobalRdrEnv? Which NameSpaces are considered relevant for a given lookup?

Constructors

SameNameSpace :: forall info. WhichGREs info	Only consider `GlobalRdrElt`s with the exact `NameSpace` we look up.
RelevantGREs	Allow `GlobalRdrElt`s with different `NameSpace`s, e.g. allow looking up record fields from the variable `NameSpace`, or looking up a `TyCon` from the data constructor `NameSpace`.
Fields :: { includeFieldSelectors :: !FieldsOrSelectors how should we handle looking up variables? should we include record fields defined with `-XNoFieldSelectors`? should we include non-fields? See Note [NoFieldSelectors]. , lookupVariablesForFields :: !Bool when looking up a record field, should we also look up plain variables? , lookupTyConsAsWell :: !Bool when looking up a variable, field or data constructor, should we also try the type constructor `NameSpace`? } -> WhichGREs GREInfo

Bundled Patterns

pattern AllRelevantGREs :: WhichGREs GREInfo	Look up as many possibly relevant `GlobalRdrElt`s as possible.
pattern RelevantGREsFOS :: FieldsOrSelectors -> WhichGREs GREInfo	Look up relevant GREs, taking into account the interaction between the variable and field `NameSpace`s as determined by the `FieldsOrSelector` argument.

Instances

Instances details

Outputable (WhichGREs info) Source #
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: WhichGREs info -> SDoc Source #

greIsRelevant Source #

Arguments

:: WhichGREs GREInfo	specification of which `GlobalRdrElt`s to consider relevant
-> NameSpace	the `NameSpace` of the thing we are looking up
-> GlobalRdrElt	the `GlobalRdrElt` we have looked up, in a potentially different `NameSpace` than we wanted
-> Bool

After looking up something with the given NameSpace, is the resulting GlobalRdrElt we have obtained relevant, according to the RelevantGREs specification of which NameSpaces are relevant?

data LookupChild Source #

Constructors

LookupChild
Fields wantedParent :: Name the parent we are looking up children of lookupDataConFirst :: Bool for type constructors, should we look in the data constructor namespace first? prioritiseParent :: Bool should we prioritise getting the right `Parent`? `True`: prioritise getting the right `Parent` `False`: prioritise getting the right `NameSpace` See Note [childGREPriority].

Instances

Instances details

Outputable LookupChild Source #
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: LookupChild -> SDoc Source #

lookupGRE_Name :: Outputable info => GlobalRdrEnvX info -> Name -> Maybe (GlobalRdrEltX info) Source #

Look for precisely this Name in the environment, in the same NameSpace as the Name.

This tests whether it is in scope, ignoring anything else that might be in scope which doesn't have the same Unique.

lookupGRE_FieldLabel :: GlobalRdrEnv -> FieldLabel -> Maybe FieldGlobalRdrElt Source #

Look for a particular record field selector in the environment.

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

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

Apply a transformation function to the GREs for these OccNames

pickGREs :: RdrName -> [GlobalRdrEltX info] -> [GlobalRdrEltX info] Source #

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 -> [GlobalRdrEltX info] -> [(GlobalRdrEltX info, GlobalRdrEltX info)] Source #

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

availFromGRE :: GlobalRdrEltX info -> AvailInfo Source #

greRdrNames :: GlobalRdrEltX info -> [RdrName] Source #

greSrcSpan :: Outputable info => GlobalRdrEltX info -> SrcSpan Source #

greQualModName :: Outputable info => GlobalRdrEltX info -> ModuleName Source #

gresToAvailInfo :: [GlobalRdrEltX info] -> [AvailInfo] Source #

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

greDefinitionModule :: GlobalRdrEltX info -> Maybe Module Source #

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

greDefinitionSrcSpan :: GlobalRdrEltX info -> SrcSpan Source #

The SrcSpan of the name pointed to by the GRE.

greFieldLabel_maybe :: GlobalRdrElt -> Maybe FieldLabel Source #

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

Global `RdrName` mapping elements: `GlobalRdrElt`, `Provenance`, `ImportSpec`

data GlobalRdrEltX info Source #

Global Reader Element

Something in scope in the renamer; usually a member of the GlobalRdrEnv. See Note [GlobalRdrElt provenance].

Why do we parametrise over the gre_info field? See Note [IfGlobalRdrEnv].

Constructors

GRE

Fields

gre_name :: !Name
gre_par :: !Parent
See Note [Parents]
gre_lcl :: !Bool
True = the thing was defined locally
gre_imp :: !(Bag ImportSpec)
In scope through these imports See Note [GlobalRdrElt provenance] for the relation between gre_lcl and gre_imp.
gre_info :: info
Information the renamer knows about this particular Name.
Careful about forcing this field! Forcing it can trigger the loading of interface files.
Note [Retrieving the GREInfo from interfaces] in GHC.Types.GREInfo.

Instances

Instances details

NFData a => NFData (GlobalRdrEltX a) Source #
Instance details Defined in GHC.Types.Name.Reader Methods rnf :: GlobalRdrEltX a -> () Source #
HasOccName (GlobalRdrEltX info) Source #
Instance details Defined in GHC.Types.Name.Reader Methods occName :: GlobalRdrEltX info -> OccName Source #
Outputable info => Outputable (GlobalRdrEltX info) Source #
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: GlobalRdrEltX info -> SDoc Source #
Data info => Data (GlobalRdrEltX info) Source #
Instance details Defined in GHC.Types.Name.Reader Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GlobalRdrEltX info -> c (GlobalRdrEltX info) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (GlobalRdrEltX info) # toConstr :: GlobalRdrEltX info -> Constr # dataTypeOf :: GlobalRdrEltX info -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (GlobalRdrEltX info)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (GlobalRdrEltX info)) # gmapT :: (forall b. Data b => b -> b) -> GlobalRdrEltX info -> GlobalRdrEltX info # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GlobalRdrEltX info -> r # gmapQ :: (forall d. Data d => d -> u) -> GlobalRdrEltX info -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GlobalRdrEltX info -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GlobalRdrEltX info -> m (GlobalRdrEltX info) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GlobalRdrEltX info -> m (GlobalRdrEltX info) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GlobalRdrEltX info -> m (GlobalRdrEltX info) #

type GlobalRdrElt = GlobalRdrEltX GREInfo Source #

Global Reader Element

Something in scope in the renamer; usually a member of the GlobalRdrEnv. See Note [GlobalRdrElt provenance].

type IfGlobalRdrElt = GlobalRdrEltX () Source #

A GlobalRdrElt in which we stripped out the GREInfo field, in order to avoid space leaks.

See Note [IfGlobalRdrEnv].

type FieldGlobalRdrElt = GlobalRdrElt Source #

A FieldGlobalRdrElt is a GlobalRdrElt in which the gre_info field is IAmRecField.

greName :: GlobalRdrEltX info -> Name Source #

greNameSpace :: GlobalRdrEltX info -> NameSpace Source #

greParent :: GlobalRdrEltX info -> Parent Source #

greInfo :: GlobalRdrElt -> GREInfo Source #

plusGRE :: GlobalRdrElt -> GlobalRdrElt -> GlobalRdrElt Source #

insertGRE :: GlobalRdrElt -> [GlobalRdrElt] -> [GlobalRdrElt] Source #

forceGlobalRdrEnv :: GlobalRdrEnvX info -> IfGlobalRdrEnv Source #

Drop all GREInfo fields in a GlobalRdrEnv in order to avoid space leaks. See Note [Forcing GREInfo] in GHC.Types.GREInfo.

hydrateGlobalRdrEnv :: (Name -> IO info) -> GlobalRdrEnvX noInfo -> GlobalRdrEnvX info Source #

Hydrate a previously dehydrated GlobalRdrEnv, by (lazily!) looking up the GREInfo using the provided function.

See Note [Forcing GREInfo] in GHC.Types.GREInfo.

isLocalGRE :: GlobalRdrEltX info -> Bool Source #

Is this GlobalRdrElt defined locally?

isImportedGRE :: GlobalRdrEltX info -> Bool Source #

Is this GlobalRdrElt imported?

Not just the negation of isLocalGRE, because it might be an Exact or Orig name reference. See Note [GlobalRdrElt provenance].

isRecFldGRE :: GlobalRdrEltX info -> Bool Source #

Is this a record field GRE?

Important: does not consult the GreInfo field.

fieldGREInfo :: HasDebugCallStack => FieldGlobalRdrElt -> RecFieldInfo Source #

isDuplicateRecFldGRE :: GlobalRdrElt -> Bool Source #

Is this a record field defined with DuplicateRecordFields?

isNoFieldSelectorGRE :: GlobalRdrElt -> Bool Source #

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

isFieldSelectorGRE :: GlobalRdrElt -> Bool Source #

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

unQualOK :: GlobalRdrEltX info -> Bool Source #

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

qualSpecOK :: ModuleName -> ImportSpec -> Bool Source #

Is in scope qualified with the given module?

unQualSpecOK :: ImportSpec -> Bool Source #

Is in scope unqualified?

pprNameProvenance :: GlobalRdrEltX info -> SDoc Source #

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

mkGRE :: (Name -> Maybe ImportSpec) -> GREInfo -> Parent -> Name -> GlobalRdrElt Source #

mkExactGRE :: Name -> GREInfo -> GlobalRdrElt Source #

mkLocalGRE :: GREInfo -> Parent -> Name -> GlobalRdrElt Source #

mkLocalVanillaGRE :: Parent -> Name -> GlobalRdrElt Source #

mkLocalTyConGRE :: TyConFlavour Name -> Name -> GlobalRdrElt Source #

Create a local GlobalRdrElt for a TyCon.

mkLocalConLikeGRE :: Parent -> (ConLikeName, ConInfo) -> GlobalRdrElt Source #

mkLocalFieldGREs :: Parent -> [(ConLikeName, ConInfo)] -> [GlobalRdrElt] Source #

gresToNameSet :: [GlobalRdrEltX info] -> NameSet Source #

Shadowing

greClashesWith :: GlobalRdrElt -> GlobalRdrElt -> Bool Source #

greClashesWith new_gre old_gre computes whether new_gre clashes with old_gre (assuming they both have the same underlying occNameFS).

shadowNames Source #

Arguments

:: Bool	discard names that are only available qualified?
-> GlobalRdrEnv
-> GlobalRdrEnv
-> GlobalRdrEnv

Information attached to a `GlobalRdrElt`

data ConLikeName Source #

The Name of a ConLike.

Useful when we are in the renamer and don't yet have a full DataCon or PatSyn to hand.

Constructors

DataConName
Fields conLikeName_Name :: !Name
PatSynName
Fields conLikeName_Name :: !Name

Instances

Instances details

NFData ConLikeName Source #
Instance details Defined in GHC.Types.GREInfo Methods rnf :: ConLikeName -> () Source #
Uniquable ConLikeName Source #
Instance details Defined in GHC.Types.GREInfo Methods getUnique :: ConLikeName -> Unique Source #
Outputable ConLikeName Source #
Instance details Defined in GHC.Types.GREInfo Methods ppr :: ConLikeName -> SDoc Source #
OutputableBndr ConLikeName Source #
Instance details Defined in GHC.Types.GREInfo Methods pprBndr :: BindingSite -> ConLikeName -> SDoc Source # pprPrefixOcc :: ConLikeName -> SDoc Source # pprInfixOcc :: ConLikeName -> SDoc Source # bndrIsJoin_maybe :: ConLikeName -> JoinPointHood Source #
Data ConLikeName Source #
Instance details Defined in GHC.Types.GREInfo Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> ConLikeName -> c ConLikeName # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c ConLikeName # toConstr :: ConLikeName -> Constr # dataTypeOf :: ConLikeName -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c ConLikeName) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ConLikeName) # gmapT :: (forall b. Data b => b -> b) -> ConLikeName -> ConLikeName # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> ConLikeName -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> ConLikeName -> r # gmapQ :: (forall d. Data d => d -> u) -> ConLikeName -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> ConLikeName -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> ConLikeName -> m ConLikeName # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> ConLikeName -> m ConLikeName # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> ConLikeName -> m ConLikeName #
Eq ConLikeName Source #
Instance details Defined in GHC.Types.GREInfo Methods (==) :: ConLikeName -> ConLikeName -> Bool # (/=) :: ConLikeName -> ConLikeName -> Bool #

data GREInfo Source #

Information about a Name that is pertinent to the renamer.

See Note [GREInfo]

Constructors

Vanilla	No particular information... e.g. a function
UnboundGRE	An unbound GRE... could be anything
IAmTyCon !(TyConFlavour Name)	`TyCon`
IAmConLike	`ConLike`
Fields !ConInfo The constructor fields. See Note [Local constructor info in the renamer]. \| Record field
IAmRecField !RecFieldInfo

Instances

Instances details

NFData GREInfo Source #
Instance details Defined in GHC.Types.GREInfo Methods rnf :: GREInfo -> () Source #
Outputable GREInfo Source #
Instance details Defined in GHC.Types.GREInfo Methods ppr :: GREInfo -> SDoc Source #
Data GREInfo Source #
Instance details Defined in GHC.Types.GREInfo Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> GREInfo -> c GREInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c GREInfo # toConstr :: GREInfo -> Constr # dataTypeOf :: GREInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c GREInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c GREInfo) # gmapT :: (forall b. Data b => b -> b) -> GREInfo -> GREInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> GREInfo -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> GREInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> GREInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> GREInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> GREInfo -> m GREInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> GREInfo -> m GREInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> GREInfo -> m GREInfo #

data RecFieldInfo Source #

Constructors

RecFieldInfo
Fields recFieldLabel :: !FieldLabel recFieldCons :: !(UniqSet ConLikeName) The constructors which have this field label. Always non-empty. NB: these constructors will always share a single parent, as the field label disambiguates between parents in the presence of duplicate record fields.

Instances

Instances details

NFData RecFieldInfo Source #
Instance details Defined in GHC.Types.GREInfo Methods rnf :: RecFieldInfo -> () Source #
Outputable RecFieldInfo Source #
Instance details Defined in GHC.Types.GREInfo Methods ppr :: RecFieldInfo -> SDoc Source #
Data RecFieldInfo Source #
Instance details Defined in GHC.Types.GREInfo Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> RecFieldInfo -> c RecFieldInfo # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c RecFieldInfo # toConstr :: RecFieldInfo -> Constr # dataTypeOf :: RecFieldInfo -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c RecFieldInfo) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c RecFieldInfo) # gmapT :: (forall b. Data b => b -> b) -> RecFieldInfo -> RecFieldInfo # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> RecFieldInfo -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> RecFieldInfo -> r # gmapQ :: (forall d. Data d => d -> u) -> RecFieldInfo -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> RecFieldInfo -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> RecFieldInfo -> m RecFieldInfo # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> RecFieldInfo -> m RecFieldInfo # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> RecFieldInfo -> m RecFieldInfo #
Eq RecFieldInfo Source #
Instance details Defined in GHC.Types.GREInfo Methods (==) :: RecFieldInfo -> RecFieldInfo -> Bool # (/=) :: RecFieldInfo -> RecFieldInfo -> Bool #

plusGREInfo :: GREInfo -> GREInfo -> GREInfo Source #

recFieldConLike_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe ConInfo Source #

recFieldInfo_maybe :: HasDebugCallStack => GlobalRdrElt -> Maybe RecFieldInfo Source #

fieldGRE_maybe :: GlobalRdrElt -> Maybe FieldGlobalRdrElt Source #

fieldGRELabel :: HasDebugCallStack => FieldGlobalRdrElt -> FieldLabel Source #

Parent information

data Parent Source #

See Note [Parents]

Constructors

NoParent
ParentIs
Fields par_is :: !Name

Instances

Instances details

NFData Parent Source #
Instance details Defined in GHC.Types.Name.Reader Methods rnf :: Parent -> () Source #
Outputable Parent Source #
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: Parent -> SDoc Source #
Data Parent Source #
Instance details 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 #
Eq Parent Source #
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: Parent -> Parent -> Bool # (/=) :: Parent -> Parent -> Bool #

greParent_maybe :: GlobalRdrEltX info -> Maybe Name Source #

mkParent :: Name -> AvailInfo -> Parent Source #

availParent :: AvailInfo -> Parent Source #

data ImportSpec Source #

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

Instances details

NFData ImportSpec Source #
Instance details Defined in GHC.Types.Name.Reader Methods rnf :: ImportSpec -> () Source #
Outputable ImportSpec Source #
Instance details Defined in GHC.Types.Name.Reader Methods ppr :: ImportSpec -> SDoc Source #
Data ImportSpec Source #
Instance details 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 #
Eq ImportSpec Source #
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: ImportSpec -> ImportSpec -> Bool # (/=) :: ImportSpec -> ImportSpec -> Bool #

data ImpDeclSpec Source #

Import Declaration Specification

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

Constructors

ImpDeclSpec

Fields

is_mod :: !Module
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_pkg_qual :: !PkgQual
Was this a package import?
is_qual :: !Bool
Was this import qualified?
is_dloc :: !SrcSpan
The location of the entire import declaration
is_isboot :: !IsBootInterface
Was this a SOURCE import?

Instances

Instances details

NFData ImpDeclSpec Source #
Instance details Defined in GHC.Types.Name.Reader Methods rnf :: ImpDeclSpec -> () Source #
Data ImpDeclSpec Source #
Instance details 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 Source #
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: ImpDeclSpec -> ImpDeclSpec -> Bool # (/=) :: ImpDeclSpec -> ImpDeclSpec -> Bool #

data ImpItemSpec Source #

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

Instances details

Data ImpItemSpec Source #
Instance details 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 Source #
Instance details Defined in GHC.Types.Name.Reader Methods (==) :: ImpItemSpec -> ImpItemSpec -> Bool # (/=) :: ImpItemSpec -> ImpItemSpec -> Bool #