topIdLvl,
-- New Ids
- newLocalName, newDFunName
+ newLocalName, newDFunName, newFamInstTyConName
) where
#include "HsVersions.h"
import HsSyn ( LRuleDecl, LHsBinds, LSig,
LHsTyVarBndr, HsTyVarBndr(..), pprLHsBinds,
- ExprCoFn(..), idCoercion, (<.>) )
+ idHsWrapper, (<.>) )
import TcIface ( tcImportDecl )
import IfaceEnv ( newGlobalBinder )
import TcRnMonad
import TcMType ( zonkTcType, zonkTcTyVarsAndFV )
-import TcType ( Type, TcKind, TcTyVar, TcTyVarSet, TcType, TvSubst,
- substTy, substTyVar, tyVarsOfType, tcTyVarsOfTypes, mkTyConApp,
+import TcType ( Type, TcKind, TcTyVar, TcTyVarSet, TcType, PredType,
+ tyVarsOfType, tcTyVarsOfTypes, mkTyConApp,
getDFunTyKey, tcTyConAppTyCon, tcGetTyVar, mkTyVarTy,
tidyOpenType, isRefineableTy
)
import TcGadt ( Refinement, refineType )
import qualified Type ( getTyVar_maybe )
-import Id ( idName, isLocalId, setIdType )
+import Id ( idName, isLocalId )
import Var ( TyVar, Id, idType, tyVarName )
import VarSet
import VarEnv
import DataCon ( DataCon )
import TyCon ( TyCon )
import Class ( Class )
-import Name ( Name, NamedThing(..), getSrcLoc, nameModule )
+import Name ( Name, NamedThing(..), getSrcLoc, nameModule_maybe, nameOccName )
import PrelNames ( thFAKE )
import NameEnv
-import OccName ( mkDFunOcc, occNameString )
-import HscTypes ( extendTypeEnvList, lookupType, TyThing(..), ExternalPackageState(..) )
+import OccName ( mkDFunOcc, occNameString, mkInstTyTcOcc )
+import HscTypes ( extendTypeEnvList, lookupType, TyThing(..),
+ ExternalPackageState(..) )
import SrcLoc ( SrcLoc, Located(..) )
import Outputable
\end{code}
Nothing -> do
-- Should it have been in the local envt?
- { let mod = nameModule name
- ; if mod == tcg_mod env || mod == thFAKE then
- notFound name -- It should be local, so panic
- -- The thFAKE possibility is because it
- -- might be in a declaration bracket
- else
- tcImportDecl name -- Go find it in an interface
+ { case nameModule_maybe name of
+ Nothing -> notFound name -- Internal names can happen in GHCi
+
+ Just mod | mod == tcg_mod env -- Names from this module
+ -> notFound name -- should be in tcg_type_env
+ | mod == thFAKE -- Names bound in TH declaration brackets
+ -> notFound name -- should be in tcg_env
+ | otherwise
+ -> tcImportDecl name -- Go find it in an interface
}}}}}
tcLookupField :: Name -> TcM Id -- Returns the selector Id
tct_level = th_lvl,
tct_type = id_ty,
tct_co = if isRefineableTy id_ty
- then Just idCoercion
+ then Just idHsWrapper
else Nothing })
| (name,id) <- names_w_ids, let id_ty = idType id]
le' = extendNameEnvList (tcl_env env) extra_env
Just d -> go tidy_env1 (d:acc) things
Nothing -> go tidy_env1 acc things
- ignore_it ty = not (tvs `intersectsVarSet` tyVarsOfType ty)
+ ignore_it ty = tvs `disjointVarSet` tyVarsOfType ty
-----------------------
find_thing ignore_it tidy_env (ATcId { tct_id = id })
[LSig Name] -- User pragmas recorded for generating
-- specialised instances
- | NewTypeDerived -- Used for deriving instances of newtypes, where the
- [Type] -- witness dictionary is identical to the argument
- -- dictionary. Hence no bindings, no pragmas
- -- The [Type] are the representation types
- -- See notes in TcDeriv
+ | NewTypeDerived -- Used for deriving instances of newtypes, where the
+ -- witness dictionary is identical to the argument
+ -- dictionary. Hence no bindings, no pragmas.
+ (Maybe [PredType])
+ -- Nothing => The newtype-derived instance involves type variables,
+ -- and the dfun has a type like df :: forall a. Eq a => Eq (T a)
+ -- Just (r:scs) => The newtype-defined instance has no type variables
+ -- so the dfun is just a constant, df :: Eq T
+ -- In this case we need to know waht the rep dict, r, and the
+ -- superclasses, scs, are. (In the Nothing case these are in the
+ -- dict fun's type.)
+ -- Invariant: these PredTypes have no free variables
+ -- NB: In both cases, the representation dict is the *first* dict.
pprInstInfo info = vcat [ptext SLIT("InstInfo:") <+> ppr (idType (iDFunId info))]
occNameString (getDFunTyKey ty)
dfun_occ = mkDFunOcc info_string is_boot index
- ; newGlobalBinder mod dfun_occ Nothing loc }
+ ; newGlobalBinder mod dfun_occ loc }
newDFunName clas [] loc = pprPanic "newDFunName" (ppr clas <+> ppr loc)
\end{code}
+Make a name for the representation tycon of a data/newtype instance. It's an
+*external* name, like otber top-level names, and hence must be made with
+newGlobalBinder.
+
+\begin{code}
+newFamInstTyConName :: Name -> SrcLoc -> TcM Name
+newFamInstTyConName tc_name loc
+ = do { index <- nextDFunIndex
+ ; mod <- getModule
+ ; let occ = nameOccName tc_name
+ ; newGlobalBinder mod (mkInstTyTcOcc index occ) loc }
+\end{code}
+
%************************************************************************
%* *
projects / ghc-hetmet.git / blobdiff