-------------------------------
Print built-in sytax right
-------------------------------
Built-in syntax, like (:) and [], is not "in scope" via the GlobalRdrEnv
in the usual way. When we print it out, we should also print it in unqualified
form, even though it's not in the environment.
I've finally bitten the (not very big) bullet, and added to Name the information
about whether or not a name is one of these built-in ones. That entailed changing
the calls to mkWiredInName, but those are exactly the places where you have to
decide whether it's built-in or not, which is fine.
Built-in syntax => It's a syntactic form, not "in scope" (e.g. [])
Wired-in thing => The thing (Id, TyCon) is fully known to the compiler,
not read from an interface file.
E.g. Bool, True, Int, Float, and many others
All built-in syntax is for wired-in things.
import Class ( Class, classTyCon, classTyVars, classSelIds )
import Var ( Id, TyVar, Var )
import VarSet ( isEmptyVarSet )
import Class ( Class, classTyCon, classTyVars, classSelIds )
import Var ( Id, TyVar, Var )
import VarSet ( isEmptyVarSet )
-import Name ( mkFCallName, mkWiredInName, Name )
+import Name ( mkFCallName, mkWiredInName, Name, BuiltInSyntax(..) )
import OccName ( mkOccFS, varName )
import PrimOp ( PrimOp, primOpSig, primOpOcc, primOpTag )
import ForeignCall ( ForeignCall )
import OccName ( mkOccFS, varName )
import PrimOp ( PrimOp, primOpSig, primOpOcc, primOpTag )
import ForeignCall ( ForeignCall )
ty = mkForAllTys tyvars (mkFunTys arg_tys res_ty)
name = mkWiredInName gHC_PRIM (primOpOcc prim_op)
(mkPrimOpIdUnique (primOpTag prim_op))
ty = mkForAllTys tyvars (mkFunTys arg_tys res_ty)
name = mkWiredInName gHC_PRIM (primOpOcc prim_op)
(mkPrimOpIdUnique (primOpTag prim_op))
+ Nothing (AnId id) UserSyntax
id = mkGlobalId (PrimOpId prim_op) name ty info
info = noCafIdInfo
id = mkGlobalId (PrimOpId prim_op) name ty info
info = noCafIdInfo
\begin{code}
mkWiredInIdName mod fs uniq id
\begin{code}
mkWiredInIdName mod fs uniq id
- = mkWiredInName mod (mkOccFS varName fs) uniq Nothing (AnId id)
+ = mkWiredInName mod (mkOccFS varName fs) uniq Nothing (AnId id) UserSyntax
unsafeCoerceName = mkWiredInIdName gHC_PRIM FSLIT("unsafeCoerce#") unsafeCoerceIdKey unsafeCoerceId
nullAddrName = mkWiredInIdName gHC_PRIM FSLIT("nullAddr#") nullAddrIdKey nullAddrId
unsafeCoerceName = mkWiredInIdName gHC_PRIM FSLIT("unsafeCoerce#") unsafeCoerceIdKey unsafeCoerceId
nullAddrName = mkWiredInIdName gHC_PRIM FSLIT("nullAddr#") nullAddrIdKey nullAddrId
-- The Name type
Name, -- Abstract
-- The Name type
Name, -- Abstract
mkInternalName, mkSystemName,
mkSystemNameEncoded, mkSysTvName,
mkFCallName, mkIPName,
mkInternalName, mkSystemName,
mkSystemNameEncoded, mkSysTvName,
mkFCallName, mkIPName,
nameSrcLoc, nameParent, nameParent_maybe,
isSystemName, isInternalName, isExternalName,
nameSrcLoc, nameParent, nameParent_maybe,
isSystemName, isInternalName, isExternalName,
- isTyVarName, isDllName, isWiredInName,
+ isTyVarName, isDllName, isWiredInName, isBuiltInSyntax,
wiredInNameTyThing_maybe,
nameIsLocalOrFrom, isHomePackageName,
wiredInNameTyThing_maybe,
nameIsLocalOrFrom, isHomePackageName,
-- e.g. data constructor of a data type, method of a class
-- Nothing => not a subordinate
-- e.g. data constructor of a data type, method of a class
-- Nothing => not a subordinate
- | WiredIn Module (Maybe Name) TyThing
+ | WiredIn Module (Maybe Name) TyThing BuiltInSyntax
-- A variant of External, for wired-in things
| Internal -- A user-defined Id or TyVar
-- A variant of External, for wired-in things
| Internal -- A user-defined Id or TyVar
| System -- A system-defined Id or TyVar. Typically the
-- OccName is very uninformative (like 's')
| System -- A system-defined Id or TyVar. Typically the
-- OccName is very uninformative (like 's')
+
+data BuiltInSyntax = BuiltInSyntax | UserSyntax
+-- BuiltInSyntax is for things like (:), [], tuples etc,
+-- which have special syntactic forms. They aren't "in scope"
+-- as such.
\end{code}
Notes about the NameSorts:
\end{code}
Notes about the NameSorts:
If any desugarer sys-locals have survived that far, they get changed to
"ds1", "ds2", etc.
If any desugarer sys-locals have survived that far, they get changed to
"ds1", "ds2", etc.
+Built-in syntax => It's a syntactic form, not "in scope" (e.g. [])
+
+Wired-in thing => The thing (Id, TyCon) is fully known to the compiler,
+ not read from an interface file.
+ E.g. Bool, True, Int, Float, and many others
+
+All built-in syntax is for wired-in things.
+
\begin{code}
nameUnique :: Name -> Unique
nameOccName :: Name -> OccName
\begin{code}
nameUnique :: Name -> Unique
nameOccName :: Name -> OccName
isHomePackageName :: Name -> Bool
isWiredInName :: Name -> Bool
isHomePackageName :: Name -> Bool
isWiredInName :: Name -> Bool
-isWiredInName (Name {n_sort = WiredIn _ _ _}) = True
-isWiredInName other = False
+isWiredInName (Name {n_sort = WiredIn _ _ _ _}) = True
+isWiredInName other = False
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
wiredInNameTyThing_maybe :: Name -> Maybe TyThing
-wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ _ thing}) = Just thing
-wiredInNameTyThing_maybe other = Nothing
+wiredInNameTyThing_maybe (Name {n_sort = WiredIn _ _ thing _}) = Just thing
+wiredInNameTyThing_maybe other = Nothing
-isExternalName (Name {n_sort = External _ _}) = True
-isExternalName (Name {n_sort = WiredIn _ _ _}) = True
-isExternalName other = False
+isBuiltInSyntax (Name {n_sort = WiredIn _ _ _ BuiltInSyntax}) = True
+isBuiltInSyntax other = False
+
+isExternalName (Name {n_sort = External _ _}) = True
+isExternalName (Name {n_sort = WiredIn _ _ _ _}) = True
+isExternalName other = False
isInternalName name = not (isExternalName name)
nameParent_maybe :: Name -> Maybe Name
isInternalName name = not (isExternalName name)
nameParent_maybe :: Name -> Maybe Name
-nameParent_maybe (Name {n_sort = External _ p}) = p
-nameParent_maybe (Name {n_sort = WiredIn _ p _}) = p
-nameParent_maybe other = Nothing
+nameParent_maybe (Name {n_sort = External _ p}) = p
+nameParent_maybe (Name {n_sort = WiredIn _ p _ _}) = p
+nameParent_maybe other = Nothing
nameParent :: Name -> Name
nameParent name = case nameParent_maybe name of
nameParent :: Name -> Name
nameParent name = case nameParent_maybe name of
nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
nameModuleName name = moduleName (nameModule name)
nameModule name = nameModule_maybe name `orElse` pprPanic "nameModule" (ppr name)
nameModuleName name = moduleName (nameModule name)
-nameModule_maybe (Name { n_sort = External mod _}) = Just mod
-nameModule_maybe (Name { n_sort = WiredIn mod _ _}) = Just mod
-nameModule_maybe name = Nothing
+nameModule_maybe (Name { n_sort = External mod _}) = Just mod
+nameModule_maybe (Name { n_sort = WiredIn mod _ _ _}) = Just mod
+nameModule_maybe name = Nothing
nameIsLocalOrFrom from name
| isExternalName name = from == nameModule name
nameIsLocalOrFrom from name
| isExternalName name = from == nameModule name
= Name { n_uniq = uniq, n_sort = External mod mb_parent,
n_occ = occ, n_loc = loc }
= Name { n_uniq = uniq, n_sort = External mod mb_parent,
n_occ = occ, n_loc = loc }
-mkWiredInName :: Module -> OccName -> Unique -> Maybe Name -> TyThing -> Name
-mkWiredInName mod occ uniq mb_parent thing
+mkWiredInName :: Module -> OccName -> Unique
+ -> Maybe Name -> TyThing -> BuiltInSyntax -> Name
+mkWiredInName mod occ uniq mb_parent thing built_in
- n_sort = WiredIn mod mb_parent thing,
+ n_sort = WiredIn mod mb_parent thing built_in,
n_occ = occ, n_loc = wiredInSrcLoc }
mkSystemName :: Unique -> UserFS -> Name
n_occ = occ, n_loc = wiredInSrcLoc }
mkSystemName :: Unique -> UserFS -> Name
pprName (Name {n_sort = sort, n_uniq = uniq, n_occ = occ})
= getPprStyle $ \ sty ->
case sort of
pprName (Name {n_sort = sort, n_uniq = uniq, n_occ = occ})
= getPprStyle $ \ sty ->
case sort of
- External mod mb_p -> pprExternal sty uniq mod occ mb_p False
- WiredIn mod mb_p thing -> pprExternal sty uniq mod occ mb_p True
- System -> pprSystem sty uniq occ
- Internal -> pprInternal sty uniq occ
+ WiredIn mod _ _ BuiltInSyntax -> pprOccName occ -- Built-in syntax is never qualified
+ WiredIn mod _ _ UserSyntax -> pprExternal sty uniq mod occ True
+ External mod _ -> pprExternal sty uniq mod occ False
+ System -> pprSystem sty uniq occ
+ Internal -> pprInternal sty uniq occ
-pprExternal sty uniq mod occ mb_p is_wired
+pprExternal sty uniq mod occ is_wired
+ | unqualStyle sty mod_name occ = pprOccName occ
| codeStyle sty = ppr mod_name <> char '_' <> pprOccName occ
| debugStyle sty = sep [ppr mod_name <> dot <> pprOccName occ,
hsep [text "{-"
| codeStyle sty = ppr mod_name <> char '_' <> pprOccName occ
| debugStyle sty = sep [ppr mod_name <> dot <> pprOccName occ,
hsep [text "{-"
-- Nothing -> empty
-- Just n -> brackets (ppr n)
, text "-}"]]
-- Nothing -> empty
-- Just n -> brackets (ppr n)
, text "-}"]]
- | unqualStyle sty mod_name occ = pprOccName occ
| otherwise = ppr mod_name <> dot <> pprOccName occ
where
mod_name = moduleName mod
| otherwise = ppr mod_name <> dot <> pprOccName occ
where
mod_name = moduleName mod
import FiniteMap ( FiniteMap )
import CoreSyn ( IdCoreRule )
import FiniteMap ( FiniteMap )
import CoreSyn ( IdCoreRule )
-import PrelNames ( isBuiltInSyntaxName )
import Maybes ( orElse )
import Outputable
import SrcLoc ( SrcSpan )
import Maybes ( orElse )
import Outputable
import SrcLoc ( SrcSpan )
%************************************************************************
%* *
%************************************************************************
%* *
-\subsection{Built-in-syntax names
-%* *
-%************************************************************************
-
-Built-in syntax names are parsed directly into Exact RdrNames.
-This predicate just identifies them.
-
-\begin{code}
-isBuiltInSyntaxName :: Name -> Bool
-isBuiltInSyntaxName n
- = isTupleKey uniq
- || uniq `elem` [listTyConKey, nilDataConKey, consDataConKey,
- funTyConKey, parrTyConKey]
- where
- uniq = nameUnique n
-\end{code}
-
-%************************************************************************
-%* *
\subsection{Known key Names}
%* *
%************************************************************************
\subsection{Known key Names}
%* *
%************************************************************************
#include "HsVersions.h"
import Var ( TyVar, mkTyVar )
#include "HsVersions.h"
import Var ( TyVar, mkTyVar )
-import Name ( Name, mkInternalName, mkWiredInName )
+import Name ( Name, BuiltInSyntax(..), mkInternalName, mkWiredInName )
import OccName ( mkVarOcc, mkOccFS, tcName )
import TyCon ( TyCon, ArgVrcs, mkPrimTyCon, mkLiftedPrimTyCon,
PrimRep(..) )
import OccName ( mkVarOcc, mkOccFS, tcName )
import TyCon ( TyCon, ArgVrcs, mkPrimTyCon, mkLiftedPrimTyCon,
PrimRep(..) )
uniq
Nothing -- No parent object
(ATyCon tycon) -- Relevant TyCon
uniq
Nothing -- No parent object
(ATyCon tycon) -- Relevant TyCon
+ UserSyntax -- None are built-in syntax
charPrimTyConName = mkPrimTc FSLIT("Char#") charPrimTyConKey charPrimTyCon
intPrimTyConName = mkPrimTc FSLIT("Int#") intPrimTyConKey intPrimTyCon
charPrimTyConName = mkPrimTc FSLIT("Char#") charPrimTyConKey charPrimTyCon
intPrimTyConName = mkPrimTc FSLIT("Int#") intPrimTyConKey intPrimTyCon
import Constants ( mAX_TUPLE_SIZE )
import Module ( Module )
import RdrName ( nameRdrName )
import Constants ( mAX_TUPLE_SIZE )
import Module ( Module )
import RdrName ( nameRdrName )
-import Name ( Name, nameUnique, nameOccName,
+import Name ( Name, BuiltInSyntax(..), nameUnique, nameOccName,
nameModule, mkWiredInName )
import OccName ( mkOccFS, tcName, dataName, mkTupleOcc, mkDataConWorkerOcc )
import DataCon ( DataCon, mkDataCon, dataConWorkId, dataConSourceArity )
nameModule, mkWiredInName )
import OccName ( mkOccFS, tcName, dataName, mkTupleOcc, mkDataConWorkerOcc )
import DataCon ( DataCon, mkDataCon, dataConWorkId, dataConSourceArity )
-mkWiredInTyConName :: Module -> FastString -> Unique -> TyCon -> Name
-mkWiredInTyConName mod fs uniq tycon
+mkWiredInTyConName :: BuiltInSyntax -> Module -> FastString -> Unique -> TyCon -> Name
+mkWiredInTyConName built_in mod fs uniq tycon
= mkWiredInName mod (mkOccFS tcName fs) uniq
Nothing -- No parent object
(ATyCon tycon) -- Relevant TyCon
= mkWiredInName mod (mkOccFS tcName fs) uniq
Nothing -- No parent object
(ATyCon tycon) -- Relevant TyCon
-mkWiredInDataConName :: Module -> FastString -> Unique -> DataCon -> Name -> Name
-mkWiredInDataConName mod fs uniq datacon parent
+mkWiredInDataConName :: BuiltInSyntax -> Module -> FastString -> Unique -> DataCon -> Name -> Name
+mkWiredInDataConName built_in mod fs uniq datacon parent
= mkWiredInName mod (mkOccFS dataName fs) uniq
(Just parent) -- Name of parent TyCon
(ADataCon datacon) -- Relevant DataCon
= mkWiredInName mod (mkOccFS dataName fs) uniq
(Just parent) -- Name of parent TyCon
(ADataCon datacon) -- Relevant DataCon
-charTyConName = mkWiredInTyConName pREL_BASE FSLIT("Char") charTyConKey charTyCon
-charDataConName = mkWiredInDataConName pREL_BASE FSLIT("C#") charDataConKey charDataCon charTyConName
-intTyConName = mkWiredInTyConName pREL_BASE FSLIT("Int") intTyConKey intTyCon
-intDataConName = mkWiredInDataConName pREL_BASE FSLIT("I#") intDataConKey intDataCon intTyConName
+charTyConName = mkWiredInTyConName UserSyntax pREL_BASE FSLIT("Char") charTyConKey charTyCon
+charDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("C#") charDataConKey charDataCon charTyConName
+intTyConName = mkWiredInTyConName UserSyntax pREL_BASE FSLIT("Int") intTyConKey intTyCon
+intDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("I#") intDataConKey intDataCon intTyConName
-boolTyConName = mkWiredInTyConName pREL_BASE FSLIT("Bool") boolTyConKey boolTyCon
-falseDataConName = mkWiredInDataConName pREL_BASE FSLIT("False") falseDataConKey falseDataCon boolTyConName
-trueDataConName = mkWiredInDataConName pREL_BASE FSLIT("True") trueDataConKey trueDataCon boolTyConName
-listTyConName = mkWiredInTyConName pREL_BASE FSLIT("[]") listTyConKey listTyCon
-nilDataConName = mkWiredInDataConName pREL_BASE FSLIT("[]") nilDataConKey nilDataCon listTyConName
-consDataConName = mkWiredInDataConName pREL_BASE FSLIT(":") consDataConKey consDataCon listTyConName
+boolTyConName = mkWiredInTyConName UserSyntax pREL_BASE FSLIT("Bool") boolTyConKey boolTyCon
+falseDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("False") falseDataConKey falseDataCon boolTyConName
+trueDataConName = mkWiredInDataConName UserSyntax pREL_BASE FSLIT("True") trueDataConKey trueDataCon boolTyConName
+listTyConName = mkWiredInTyConName BuiltInSyntax pREL_BASE FSLIT("[]") listTyConKey listTyCon
+nilDataConName = mkWiredInDataConName BuiltInSyntax pREL_BASE FSLIT("[]") nilDataConKey nilDataCon listTyConName
+consDataConName = mkWiredInDataConName BuiltInSyntax pREL_BASE FSLIT(":") consDataConKey consDataCon listTyConName
-floatTyConName = mkWiredInTyConName pREL_FLOAT FSLIT("Float") floatTyConKey floatTyCon
-floatDataConName = mkWiredInDataConName pREL_FLOAT FSLIT("F#") floatDataConKey floatDataCon floatTyConName
-doubleTyConName = mkWiredInTyConName pREL_FLOAT FSLIT("Double") doubleTyConKey doubleTyCon
-doubleDataConName = mkWiredInDataConName pREL_FLOAT FSLIT("D#") doubleDataConKey doubleDataCon doubleTyConName
+floatTyConName = mkWiredInTyConName UserSyntax pREL_FLOAT FSLIT("Float") floatTyConKey floatTyCon
+floatDataConName = mkWiredInDataConName UserSyntax pREL_FLOAT FSLIT("F#") floatDataConKey floatDataCon floatTyConName
+doubleTyConName = mkWiredInTyConName UserSyntax pREL_FLOAT FSLIT("Double") doubleTyConKey doubleTyCon
+doubleDataConName = mkWiredInDataConName UserSyntax pREL_FLOAT FSLIT("D#") doubleDataConKey doubleDataCon doubleTyConName
-parrTyConName = mkWiredInTyConName pREL_PARR FSLIT("[::]") parrTyConKey parrTyCon
-parrDataConName = mkWiredInDataConName pREL_PARR FSLIT("PArr") parrDataConKey parrDataCon parrTyConName
+parrTyConName = mkWiredInTyConName BuiltInSyntax pREL_PARR FSLIT("[::]") parrTyConKey parrTyCon
+parrDataConName = mkWiredInDataConName UserSyntax pREL_PARR FSLIT("PArr") parrDataConKey parrDataCon parrTyConName
boolTyCon_RDR = nameRdrName boolTyConName
false_RDR = nameRdrName falseDataConName
boolTyCon_RDR = nameRdrName boolTyConName
false_RDR = nameRdrName falseDataConName
wrk_key = incrUnique (nameUnique dc_name)
wrk_name = mkWiredInName mod wrk_occ wrk_key
(Just (tyConName tycon))
wrk_key = incrUnique (nameUnique dc_name)
wrk_name = mkWiredInName mod wrk_occ wrk_key
(Just (tyConName tycon))
- (AnId (dataConWorkId data_con))
+ (AnId (dataConWorkId data_con)) UserSyntax
bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
-- Wired-in types are too simple to need wrappers
\end{code}
bogus_wrap_name = pprPanic "Wired-in data wrapper id" (ppr dc_name)
-- Wired-in types are too simple to need wrappers
\end{code}
tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
mod = mkTupleModule boxity arity
tc_name = mkWiredInName mod (mkTupleOcc tcName boxity arity) tc_uniq
tycon = mkTupleTyCon tc_name tc_kind arity tyvars tuple_con boxity gen_info
mod = mkTupleModule boxity arity
tc_name = mkWiredInName mod (mkTupleOcc tcName boxity arity) tc_uniq
+ Nothing (ATyCon tycon) BuiltInSyntax
tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
res_kind | isBoxed boxity = liftedTypeKind
| otherwise = ubxTupleKind
tc_kind = mkArrowKinds (map tyVarKind tyvars) res_kind
res_kind | isBoxed boxity = liftedTypeKind
| otherwise = ubxTupleKind
tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
tyvar_tys = mkTyVarTys tyvars
dc_name = mkWiredInName mod (mkTupleOcc dataName boxity arity) dc_uniq
tuple_con = pcDataCon dc_name tyvars tyvar_tys tycon
tyvar_tys = mkTyVarTys tyvars
dc_name = mkWiredInName mod (mkTupleOcc dataName boxity arity) dc_uniq
- (Just tc_name) (ADataCon tuple_con)
+ (Just tc_name) (ADataCon tuple_con) BuiltInSyntax
tc_uniq = mkTupleTyConUnique boxity arity
dc_uniq = mkTupleDataConUnique boxity arity
gen_info = True -- Tuples all have generics..
tc_uniq = mkTupleTyConUnique boxity arity
dc_uniq = mkTupleDataConUnique boxity arity
gen_info = True -- Tuples all have generics..
tyvarTys = replicate arity $ mkTyVarTy tyvar
nameStr = mkFastString ("MkPArr" ++ show arity)
name = mkWiredInName pREL_PARR (mkOccFS dataName nameStr) uniq
tyvarTys = replicate arity $ mkTyVarTy tyvar
nameStr = mkFastString ("MkPArr" ++ show arity)
name = mkWiredInName pREL_PARR (mkOccFS dataName nameStr) uniq
- Nothing (ADataCon data_con)
+ Nothing (ADataCon data_con) UserSyntax
uniq = mkPArrDataConUnique arity
-- checks whether a data constructor is a fake constructor for parallel arrays
uniq = mkPArrDataConUnique arity
-- checks whether a data constructor is a fake constructor for parallel arrays
import TcRnMonad
import FiniteMap
import TcRnMonad
import FiniteMap
-import PrelNames ( pRELUDE_Name, isBuiltInSyntaxName, isUnboundName,
+import PrelNames ( pRELUDE_Name, isUnboundName,
main_RDR_Unqual )
import Module ( Module, ModuleName, moduleName, mkPackageModule,
moduleNameUserString, isHomeModule,
unitModuleEnvByName, unitModuleEnv,
lookupModuleEnvByName, moduleEnvElts )
import Name ( Name, nameSrcLoc, nameOccName, nameModuleName, isWiredInName,
main_RDR_Unqual )
import Module ( Module, ModuleName, moduleName, mkPackageModule,
moduleNameUserString, isHomeModule,
unitModuleEnvByName, unitModuleEnv,
lookupModuleEnvByName, moduleEnvElts )
import Name ( Name, nameSrcLoc, nameOccName, nameModuleName, isWiredInName,
- nameParent, nameParent_maybe, isExternalName, nameModule )
+ nameParent, nameParent_maybe, isExternalName, nameModule,
+ isBuiltInSyntax )
import NameSet
import NameEnv
import OccName ( srcDataName, isTcOcc, occNameFlavour, OccEnv,
import NameSet
import NameEnv
import OccName ( srcDataName, isTcOcc, occNameFlavour, OccEnv,
avails' | implicit_prelude = filter not_built_in_syntax avails
| otherwise = avails
avails' | implicit_prelude = filter not_built_in_syntax avails
| otherwise = avails
- not_built_in_syntax a = not (all isBuiltInSyntaxName (availNames a))
+ not_built_in_syntax a = not (all isBuiltInSyntax (availNames a))
-- Only filter it if all the names of the avail are built-in
-- In particular, lists have (:) which is not built in syntax
-- Only filter it if all the names of the avail are built-in
-- In particular, lists have (:) which is not built in syntax
- -- so we don't filter it out. [Sept 03: wrong: see isBuiltInSyntaxName]
+ -- so we don't filter it out. [Sept 03: wrong: see isBuiltInSyntax]
avail_env = mkAvailEnv avails'
imports = emptyImportAvails {
avail_env = mkAvailEnv avails'
imports = emptyImportAvails {
import Var ( Id, TyVar, tyVarKind )
import VarEnv ( TyVarEnv )
import VarSet ( TyVarSet )
import Var ( Id, TyVar, tyVarKind )
import VarEnv ( TyVarEnv )
import VarSet ( TyVarSet )
-import Name ( Name, NamedThing(..), mkWiredInName )
+import Name ( Name, NamedThing(..), BuiltInSyntax(..), mkWiredInName )
import OccName ( mkOccFS, tcName )
import BasicTypes ( IPName, tupleParens )
import TyCon ( TyCon, mkFunTyCon, tyConArity, tupleTyConBoxity, isTupleTyCon, isRecursiveTyCon )
import OccName ( mkOccFS, tcName )
import BasicTypes ( IPName, tupleParens )
import TyCon ( TyCon, mkFunTyCon, tyConArity, tupleTyConBoxity, isTupleTyCon, isRecursiveTyCon )
funTyConKey
Nothing -- No parent object
(ATyCon funTyCon) -- Relevant TyCon
funTyConKey
Nothing -- No parent object
(ATyCon funTyCon) -- Relevant TyCon