Get rid of tcView altogether
authorÖmer Sinan Ağacan <omeragacan@gmail.com>
Mon, 7 Dec 2015 16:41:51 +0000 (11:41 -0500)
committerÖmer Sinan Ağacan <omeragacan@gmail.com>
Mon, 7 Dec 2015 22:15:07 +0000 (17:15 -0500)
This is just a trivial renaming that implements a ToDo mentioned in a comment
in Type.hs.

Adding Simon as reviewer since he added the ToDo comment.

Reviewers: simonpj, austin, goldfire, bgamari

Subscribers: thomie

Differential Revision: https://phabricator.haskell.org/D1584

compiler/typecheck/FamInst.hs
compiler/typecheck/TcCanonical.hs
compiler/typecheck/TcErrors.hs
compiler/typecheck/TcType.hs
compiler/typecheck/TcUnify.hs
compiler/typecheck/TcValidity.hs
compiler/types/Type.hs
compiler/types/Unify.hs

index 93de504..26db100 100644 (file)
@@ -500,7 +500,7 @@ unusedInjTvsInRHS injList lhs rhs =
 isTFHeaded :: Type -> Bool
 -- See Note [Verifying injectivity annotation]. This function implements third
 -- check described there.
 isTFHeaded :: Type -> Bool
 -- See Note [Verifying injectivity annotation]. This function implements third
 -- check described there.
-isTFHeaded ty | Just ty' <- tcView ty
+isTFHeaded ty | Just ty' <- coreView ty
               = isTFHeaded ty'
 isTFHeaded ty | (TyConApp tc args) <- ty
               , isTypeFamilyTyCon tc
               = isTFHeaded ty'
 isTFHeaded ty | (TyConApp tc args) <- ty
               , isTypeFamilyTyCon tc
index 693299b..bc485d7 100644 (file)
@@ -448,8 +448,8 @@ can_eq_nc'
 
 -- Expand synonyms first; see Note [Type synonyms and canonicalization]
 can_eq_nc' flat _rdr_env _envs ev eq_rel ty1 ps_ty1 ty2 ps_ty2
 
 -- Expand synonyms first; see Note [Type synonyms and canonicalization]
 can_eq_nc' flat _rdr_env _envs ev eq_rel ty1 ps_ty1 ty2 ps_ty2
-  | Just ty1' <- tcView ty1 = can_eq_nc flat ev eq_rel ty1' ps_ty1 ty2  ps_ty2
-  | Just ty2' <- tcView ty2 = can_eq_nc flat ev eq_rel ty1  ps_ty1 ty2' ps_ty2
+  | Just ty1' <- coreView ty1 = can_eq_nc flat ev eq_rel ty1' ps_ty1 ty2  ps_ty2
+  | Just ty2' <- coreView ty2 = can_eq_nc flat ev eq_rel ty1  ps_ty1 ty2' ps_ty2
 
 -- need to check for reflexivity in the ReprEq case.
 -- See Note [Eager reflexivity check]
 
 -- need to check for reflexivity in the ReprEq case.
 -- See Note [Eager reflexivity check]
@@ -1594,8 +1594,8 @@ unifyWanted _   Phantom ty1      ty2      = return (mkTcPhantomCo ty1 ty2)
 unifyWanted loc role    orig_ty1 orig_ty2
   = go orig_ty1 orig_ty2
   where
 unifyWanted loc role    orig_ty1 orig_ty2
   = go orig_ty1 orig_ty2
   where
-    go ty1 ty2 | Just ty1' <- tcView ty1 = go ty1' ty2
-    go ty1 ty2 | Just ty2' <- tcView ty2 = go ty1 ty2'
+    go ty1 ty2 | Just ty1' <- coreView ty1 = go ty1' ty2
+    go ty1 ty2 | Just ty2' <- coreView ty2 = go ty1 ty2'
 
     go (FunTy s1 t1) (FunTy s2 t2)
       = do { co_s <- unifyWanted loc role s1 s2
 
     go (FunTy s1 t1) (FunTy s2 t2)
       = do { co_s <- unifyWanted loc role s1 s2
@@ -1639,8 +1639,8 @@ unify_derived _   Phantom _        _        = return ()
 unify_derived loc role    orig_ty1 orig_ty2
   = go orig_ty1 orig_ty2
   where
 unify_derived loc role    orig_ty1 orig_ty2
   = go orig_ty1 orig_ty2
   where
-    go ty1 ty2 | Just ty1' <- tcView ty1 = go ty1' ty2
-    go ty1 ty2 | Just ty2' <- tcView ty2 = go ty1 ty2'
+    go ty1 ty2 | Just ty1' <- coreView ty1 = go ty1' ty2
+    go ty1 ty2 | Just ty2' <- coreView ty2 = go ty1 ty2'
 
     go (FunTy s1 t1) (FunTy s2 t2)
       = do { unify_derived loc role s1 s2
 
     go (FunTy s1 t1) (FunTy s2 t2)
       = do { unify_derived loc role s1 s2
index ad389b2..05befd5 100644 (file)
@@ -1420,7 +1420,7 @@ expandSynonymsToMatch ty1 ty2 = (ty1_ret, ty2_ret)
          in (exps + sum exps', TyConApp tc1 tys1', TyConApp tc2 tys2')
       | otherwise =
         -- Try to expand type constructors
          in (exps + sum exps', TyConApp tc1 tys1', TyConApp tc2 tys2')
       | otherwise =
         -- Try to expand type constructors
-        case (tcView t1, tcView t2) of
+        case (coreView t1, coreView t2) of
           -- When only one of the constructors is a synonym, we just
           -- expand it and continue search
           (Just t1', Nothing) ->
           -- When only one of the constructors is a synonym, we just
           -- expand it and continue search
           (Just t1', Nothing) ->
@@ -1439,12 +1439,12 @@ expandSynonymsToMatch ty1 ty2 = (ty1_ret, ty2_ret)
             (exps, t1, t2)
 
     go exps t1@TyConApp{} t2
             (exps, t1, t2)
 
     go exps t1@TyConApp{} t2
-      | Just t1' <- tcView t1 = go (exps + 1) t1' t2
-      | otherwise             = (exps, t1, t2)
+      | Just t1' <- coreView t1 = go (exps + 1) t1' t2
+      | otherwise               = (exps, t1, t2)
 
     go exps t1 t2@TyConApp{}
 
     go exps t1 t2@TyConApp{}
-      | Just t2' <- tcView t2 = go (exps + 1) t1 t2'
-      | otherwise             = (exps, t1, t2)
+      | Just t2' <- coreView t2 = go (exps + 1) t1 t2'
+      | otherwise               = (exps, t1, t2)
 
     go exps (AppTy t1_1 t1_2) (AppTy t2_1 t2_2) =
       let (exps1, t1_1', t2_1') = go 0 t1_1 t2_1
 
     go exps (AppTy t1_1 t1_2) (AppTy t2_1 t2_2) =
       let (exps1, t1_1', t2_1') = go 0 t1_1 t2_1
@@ -1893,7 +1893,7 @@ we want to give it a bit of structure.  Here's the plan
 
 quickFlattenTy :: TcType -> TcM TcType
 -- See Note [Flattening in error message generation]
 
 quickFlattenTy :: TcType -> TcM TcType
 -- See Note [Flattening in error message generation]
-quickFlattenTy ty | Just ty' <- tcView ty = quickFlattenTy ty'
+quickFlattenTy ty | Just ty' <- coreView ty = quickFlattenTy ty'
 quickFlattenTy ty@(TyVarTy {})  = return ty
 quickFlattenTy ty@(ForAllTy {}) = return ty     -- See
 quickFlattenTy ty@(LitTy {})    = return ty
 quickFlattenTy ty@(TyVarTy {})  = return ty
 quickFlattenTy ty@(ForAllTy {}) = return ty     -- See
 quickFlattenTy ty@(LitTy {})    = return ty
index 60ab685..701f27c 100644 (file)
@@ -50,7 +50,6 @@ module TcType (
   --------------------------------
   -- Splitters
   -- These are important because they do not look through newtypes
   --------------------------------
   -- Splitters
   -- These are important because they do not look through newtypes
-  tcView,
   tcSplitForAllTys, tcSplitPhiTy, tcSplitPredFunTy_maybe,
   tcSplitFunTy_maybe, tcSplitFunTys, tcFunArgTy, tcFunResultTy, tcSplitFunTysN,
   tcSplitTyConApp, tcSplitTyConApp_maybe, tcTyConAppTyCon, tcTyConAppArgs,
   tcSplitForAllTys, tcSplitPhiTy, tcSplitPredFunTy_maybe,
   tcSplitFunTy_maybe, tcSplitFunTys, tcFunArgTy, tcFunResultTy, tcSplitFunTysN,
   tcSplitTyConApp, tcSplitTyConApp_maybe, tcTyConAppTyCon, tcTyConAppArgs,
@@ -629,7 +628,7 @@ isSigMaybe _                = Nothing
 -- after expanding synonyms.
 tcTyFamInsts :: Type -> [(TyCon, [Type])]
 tcTyFamInsts ty
 -- after expanding synonyms.
 tcTyFamInsts :: Type -> [(TyCon, [Type])]
 tcTyFamInsts ty
-  | Just exp_ty <- tcView ty    = tcTyFamInsts exp_ty
+  | Just exp_ty <- coreView ty  = tcTyFamInsts exp_ty
 tcTyFamInsts (TyVarTy _)        = []
 tcTyFamInsts (TyConApp tc tys)
   | isTypeFamilyTyCon tc        = [(tc, tys)]
 tcTyFamInsts (TyVarTy _)        = []
 tcTyFamInsts (TyConApp tc tys)
   | isTypeFamilyTyCon tc        = [(tc, tys)]
@@ -681,7 +680,7 @@ exactTyVarsOfType :: Type -> TyVarSet
 exactTyVarsOfType ty
   = go ty
   where
 exactTyVarsOfType ty
   = go ty
   where
-    go ty | Just ty' <- tcView ty = go ty'  -- This is the key line
+    go ty | Just ty' <- coreView ty = go ty'  -- This is the key line
     go (TyVarTy tv)         = unitVarSet tv
     go (TyConApp _ tys)     = exactTyVarsOfTypes tys
     go (LitTy {})           = emptyVarSet
     go (TyVarTy tv)         = unitVarSet tv
     go (TyConApp _ tys)     = exactTyVarsOfTypes tys
     go (LitTy {})           = emptyVarSet
@@ -910,7 +909,7 @@ mkTcEqPredRole Phantom          = panic "mkTcEqPredRole Phantom"
 -- @isTauTy@ tests for nested for-alls.
 
 isTauTy :: Type -> Bool
 -- @isTauTy@ tests for nested for-alls.
 
 isTauTy :: Type -> Bool
-isTauTy ty | Just ty' <- tcView ty = isTauTy ty'
+isTauTy ty | Just ty' <- coreView ty = isTauTy ty'
 isTauTy (TyVarTy _)       = True
 isTauTy (LitTy {})        = True
 isTauTy (TyConApp tc tys) = all isTauTy tys && isTauTyCon tc
 isTauTy (TyVarTy _)       = True
 isTauTy (LitTy {})        = True
 isTauTy (TyConApp tc tys) = all isTauTy tys && isTauTyCon tc
@@ -927,7 +926,7 @@ isTauTyCon tc
 ---------------
 getDFunTyKey :: Type -> OccName -- Get some string from a type, to be used to
                                 -- construct a dictionary function name
 ---------------
 getDFunTyKey :: Type -> OccName -- Get some string from a type, to be used to
                                 -- construct a dictionary function name
-getDFunTyKey ty | Just ty' <- tcView ty = getDFunTyKey ty'
+getDFunTyKey ty | Just ty' <- coreView ty = getDFunTyKey ty'
 getDFunTyKey (TyVarTy tv)    = getOccName tv
 getDFunTyKey (TyConApp tc _) = getOccName tc
 getDFunTyKey (LitTy x)       = getDFunTyLitKey x
 getDFunTyKey (TyVarTy tv)    = getOccName tv
 getDFunTyKey (TyConApp tc _) = getOccName tc
 getDFunTyKey (LitTy x)       = getDFunTyLitKey x
@@ -956,19 +955,19 @@ variables.  It's up to you to make sure this doesn't matter.
 tcSplitForAllTys :: Type -> ([TyVar], Type)
 tcSplitForAllTys ty = split ty ty []
    where
 tcSplitForAllTys :: Type -> ([TyVar], Type)
 tcSplitForAllTys ty = split ty ty []
    where
-     split orig_ty ty tvs | Just ty' <- tcView ty = split orig_ty ty' tvs
+     split orig_ty ty tvs | Just ty' <- coreView ty = split orig_ty ty' tvs
      split _ (ForAllTy tv ty) tvs = split ty ty (tv:tvs)
      split orig_ty _          tvs = (reverse tvs, orig_ty)
 
 tcIsForAllTy :: Type -> Bool
      split _ (ForAllTy tv ty) tvs = split ty ty (tv:tvs)
      split orig_ty _          tvs = (reverse tvs, orig_ty)
 
 tcIsForAllTy :: Type -> Bool
-tcIsForAllTy ty | Just ty' <- tcView ty = tcIsForAllTy ty'
+tcIsForAllTy ty | Just ty' <- coreView ty = tcIsForAllTy ty'
 tcIsForAllTy (ForAllTy {}) = True
 tcIsForAllTy _             = False
 
 tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)
 -- Split off the first predicate argument from a type
 tcSplitPredFunTy_maybe ty
 tcIsForAllTy (ForAllTy {}) = True
 tcIsForAllTy _             = False
 
 tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)
 -- Split off the first predicate argument from a type
 tcSplitPredFunTy_maybe ty
-  | Just ty' <- tcView ty = tcSplitPredFunTy_maybe ty'
+  | Just ty' <- coreView ty = tcSplitPredFunTy_maybe ty'
 tcSplitPredFunTy_maybe (FunTy arg res)
   | isPredTy arg = Just (arg, res)
 tcSplitPredFunTy_maybe _
 tcSplitPredFunTy_maybe (FunTy arg res)
   | isPredTy arg = Just (arg, res)
 tcSplitPredFunTy_maybe _
@@ -1022,7 +1021,7 @@ tcSplitTyConApp ty = case tcSplitTyConApp_maybe ty of
                         Nothing    -> pprPanic "tcSplitTyConApp" (pprType ty)
 
 tcSplitTyConApp_maybe :: Type -> Maybe (TyCon, [Type])
                         Nothing    -> pprPanic "tcSplitTyConApp" (pprType ty)
 
 tcSplitTyConApp_maybe :: Type -> Maybe (TyCon, [Type])
-tcSplitTyConApp_maybe ty | Just ty' <- tcView ty = tcSplitTyConApp_maybe ty'
+tcSplitTyConApp_maybe ty | Just ty' <- coreView ty = tcSplitTyConApp_maybe ty'
 tcSplitTyConApp_maybe (TyConApp tc tys) = Just (tc, tys)
 tcSplitTyConApp_maybe (FunTy arg res)   = Just (funTyCon, [arg,res])
         -- Newtypes are opaque, so they may be split
 tcSplitTyConApp_maybe (TyConApp tc tys) = Just (tc, tys)
 tcSplitTyConApp_maybe (FunTy arg res)   = Just (funTyCon, [arg,res])
         -- Newtypes are opaque, so they may be split
@@ -1039,7 +1038,7 @@ tcSplitFunTys ty = case tcSplitFunTy_maybe ty of
                                           (args,res') = tcSplitFunTys res
 
 tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)
                                           (args,res') = tcSplitFunTys res
 
 tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)
-tcSplitFunTy_maybe ty | Just ty' <- tcView ty           = tcSplitFunTy_maybe ty'
+tcSplitFunTy_maybe ty | Just ty' <- coreView ty         = tcSplitFunTy_maybe ty'
 tcSplitFunTy_maybe (FunTy arg res) | not (isPredTy arg) = Just (arg, res)
 tcSplitFunTy_maybe _                                    = Nothing
         -- Note the typeKind guard
 tcSplitFunTy_maybe (FunTy arg res) | not (isPredTy arg) = Just (arg, res)
 tcSplitFunTy_maybe _                                    = Nothing
         -- Note the typeKind guard
@@ -1076,7 +1075,7 @@ tcFunResultTy ty = snd (tcSplitFunTy ty)
 
 -----------------------
 tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)
 
 -----------------------
 tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)
-tcSplitAppTy_maybe ty | Just ty' <- tcView ty = tcSplitAppTy_maybe ty'
+tcSplitAppTy_maybe ty | Just ty' <- coreView ty = tcSplitAppTy_maybe ty'
 tcSplitAppTy_maybe ty = repSplitAppTy_maybe ty
 
 tcSplitAppTy :: Type -> (Type, Type)
 tcSplitAppTy_maybe ty = repSplitAppTy_maybe ty
 
 tcSplitAppTy :: Type -> (Type, Type)
@@ -1094,7 +1093,7 @@ tcSplitAppTys ty
 
 -----------------------
 tcGetTyVar_maybe :: Type -> Maybe TyVar
 
 -----------------------
 tcGetTyVar_maybe :: Type -> Maybe TyVar
-tcGetTyVar_maybe ty | Just ty' <- tcView ty = tcGetTyVar_maybe ty'
+tcGetTyVar_maybe ty | Just ty' <- coreView ty = tcGetTyVar_maybe ty'
 tcGetTyVar_maybe (TyVarTy tv)   = Just tv
 tcGetTyVar_maybe _              = Nothing
 
 tcGetTyVar_maybe (TyVarTy tv)   = Just tv
 tcGetTyVar_maybe _              = Nothing
 
@@ -1137,7 +1136,7 @@ tcInstHeadTyAppAllTyVars :: Type -> Bool
 -- These must be a constructor applied to type variable arguments.
 -- But we allow kind instantiations.
 tcInstHeadTyAppAllTyVars ty
 -- These must be a constructor applied to type variable arguments.
 -- But we allow kind instantiations.
 tcInstHeadTyAppAllTyVars ty
-  | Just ty' <- tcView ty       -- Look through synonyms
+  | Just ty' <- coreView ty       -- Look through synonyms
   = tcInstHeadTyAppAllTyVars ty'
   | otherwise
   = case ty of
   = tcInstHeadTyAppAllTyVars ty'
   | otherwise
   = case ty of
@@ -1169,8 +1168,8 @@ tcEqType ty1 ty2
   = go init_env ty1 ty2
   where
     init_env = mkRnEnv2 (mkInScopeSet (tyVarsOfType ty1 `unionVarSet` tyVarsOfType ty2))
   = go init_env ty1 ty2
   where
     init_env = mkRnEnv2 (mkInScopeSet (tyVarsOfType ty1 `unionVarSet` tyVarsOfType ty2))
-    go env t1 t2 | Just t1' <- tcView t1 = go env t1' t2
-                 | Just t2' <- tcView t2 = go env t1 t2'
+    go env t1 t2 | Just t1' <- coreView t1 = go env t1' t2
+                 | Just t2' <- coreView t2 = go env t1 t2'
     go env (TyVarTy tv1)       (TyVarTy tv2)     = rnOccL env tv1 == rnOccR env tv2
     go _   (LitTy lit1)        (LitTy lit2)      = lit1 == lit2
     go env (ForAllTy tv1 t1)   (ForAllTy tv2 t2) = go env (tyVarKind tv1) (tyVarKind tv2)
     go env (TyVarTy tv1)       (TyVarTy tv2)     = rnOccL env tv1 == rnOccR env tv2
     go _   (LitTy lit1)        (LitTy lit2)      = lit1 == lit2
     go env (ForAllTy tv1 t1)   (ForAllTy tv2 t2) = go env (tyVarKind tv1) (tyVarKind tv2)
@@ -1255,9 +1254,9 @@ occurCheckExpand dflags tv ty
     impredicative = canUnifyWithPolyType dflags details (tyVarKind tv)
 
     -- Check 'ty' is a tyvar, or can be expanded into one
     impredicative = canUnifyWithPolyType dflags details (tyVarKind tv)
 
     -- Check 'ty' is a tyvar, or can be expanded into one
-    go_sig_tv ty@(TyVarTy {})            = OC_OK ty
-    go_sig_tv ty | Just ty' <- tcView ty = go_sig_tv ty'
-    go_sig_tv _                          = OC_NonTyVar
+    go_sig_tv ty@(TyVarTy {})              = OC_OK ty
+    go_sig_tv ty | Just ty' <- coreView ty = go_sig_tv ty'
+    go_sig_tv _                            = OC_NonTyVar
 
     -- True => fine
     fast_check (LitTy {})        = True
 
     -- True => fine
     fast_check (LitTy {})        = True
@@ -1301,8 +1300,8 @@ occurCheckExpand dflags tv ty
               -> return ty  -- First try to eliminate the tyvar from the args
               | otherwise
               -> OC_Forall  -- A type synonym with a forall on the RHS
               -> return ty  -- First try to eliminate the tyvar from the args
               | otherwise
               -> OC_Forall  -- A type synonym with a forall on the RHS
-          bad | Just ty' <- tcView ty -> go ty'
-              | otherwise             -> bad
+          bad | Just ty' <- coreView ty -> go ty'
+              | otherwise               -> bad
                       -- Failing that, try to expand a synonym
 
 canUnifyWithPolyType :: DynFlags -> TcTyVarDetails -> TcKind -> Bool
                       -- Failing that, try to expand a synonym
 
 canUnifyWithPolyType :: DynFlags -> TcTyVarDetails -> TcKind -> Bool
@@ -1445,13 +1444,13 @@ isSigmaTy :: TcType -> Bool
 -- isSigmaTy returns true of any qualified type.  It doesn't
 -- *necessarily* have any foralls.  E.g
 --        f :: (?x::Int) => Int -> Int
 -- isSigmaTy returns true of any qualified type.  It doesn't
 -- *necessarily* have any foralls.  E.g
 --        f :: (?x::Int) => Int -> Int
-isSigmaTy ty | Just ty' <- tcView ty = isSigmaTy ty'
+isSigmaTy ty | Just ty' <- coreView ty = isSigmaTy ty'
 isSigmaTy (ForAllTy _ _) = True
 isSigmaTy (FunTy a _)    = isPredTy a
 isSigmaTy _              = False
 
 isRhoTy :: TcType -> Bool   -- True of TcRhoTypes; see Note [TcRhoType]
 isSigmaTy (ForAllTy _ _) = True
 isSigmaTy (FunTy a _)    = isPredTy a
 isSigmaTy _              = False
 
 isRhoTy :: TcType -> Bool   -- True of TcRhoTypes; see Note [TcRhoType]
-isRhoTy ty | Just ty' <- tcView ty = isRhoTy ty'
+isRhoTy ty | Just ty' <- coreView ty = isRhoTy ty'
 isRhoTy (ForAllTy {}) = False
 isRhoTy (FunTy a r)   = not (isPredTy a) && isRhoTy r
 isRhoTy _             = True
 isRhoTy (ForAllTy {}) = False
 isRhoTy (FunTy a r)   = not (isPredTy a) && isRhoTy r
 isRhoTy _             = True
@@ -1459,7 +1458,7 @@ isRhoTy _             = True
 isOverloadedTy :: Type -> Bool
 -- Yes for a type of a function that might require evidence-passing
 -- Used only by bindLocalMethods
 isOverloadedTy :: Type -> Bool
 -- Yes for a type of a function that might require evidence-passing
 -- Used only by bindLocalMethods
-isOverloadedTy ty | Just ty' <- tcView ty = isOverloadedTy ty'
+isOverloadedTy ty | Just ty' <- coreView ty = isOverloadedTy ty'
 isOverloadedTy (ForAllTy _ ty) = isOverloadedTy ty
 isOverloadedTy (FunTy a _)     = isPredTy a
 isOverloadedTy _               = False
 isOverloadedTy (ForAllTy _ ty) = isOverloadedTy ty
 isOverloadedTy (FunTy a _)     = isPredTy a
 isOverloadedTy _               = False
@@ -1514,7 +1513,7 @@ isTyVarExposed _  (ForAllTy {})   = False
 isTyVarUnderDatatype :: TcTyVar -> TcType -> Bool
 isTyVarUnderDatatype tv = go False
   where
 isTyVarUnderDatatype :: TcTyVar -> TcType -> Bool
 isTyVarUnderDatatype tv = go False
   where
-    go under_dt ty | Just ty' <- tcView ty = go under_dt ty'
+    go under_dt ty | Just ty' <- coreView ty = go under_dt ty'
     go under_dt (TyVarTy tv') = under_dt && (tv == tv')
     go under_dt (TyConApp tc tys) = let under_dt' = under_dt ||
                                                     isGenerativeTyCon tc
     go under_dt (TyVarTy tv') = under_dt && (tv == tv')
     go under_dt (TyConApp tc tys) = let under_dt' = under_dt ||
                                                     isGenerativeTyCon tc
@@ -1594,7 +1593,7 @@ toTcTypeBag evvars = mapBag (\tv -> setTyVarKind tv (toTcType (tyVarKind tv))) e
 
 deNoteType :: Type -> Type
 -- Remove all *outermost* type synonyms and other notes
 
 deNoteType :: Type -> Type
 -- Remove all *outermost* type synonyms and other notes
-deNoteType ty | Just ty' <- tcView ty = deNoteType ty'
+deNoteType ty | Just ty' <- coreView ty = deNoteType ty'
 deNoteType ty = ty
 
 tcTyVarsOfType :: Type -> TcTyVarSet
 deNoteType ty = ty
 
 tcTyVarsOfType :: Type -> TcTyVarSet
@@ -1623,7 +1622,7 @@ orphNamesOfTyCon tycon = unitNameSet (getName tycon) `unionNameSet` case tyConCl
     Just cls -> unitNameSet (getName cls)
 
 orphNamesOfType :: Type -> NameSet
     Just cls -> unitNameSet (getName cls)
 
 orphNamesOfType :: Type -> NameSet
-orphNamesOfType ty | Just ty' <- tcView ty = orphNamesOfType ty'
+orphNamesOfType ty | Just ty' <- coreView ty = orphNamesOfType ty'
                 -- Look through type synonyms (Trac #4912)
 orphNamesOfType (TyVarTy _)          = emptyNameSet
 orphNamesOfType (LitTy {})           = emptyNameSet
                 -- Look through type synonyms (Trac #4912)
 orphNamesOfType (TyVarTy _)          = emptyNameSet
 orphNamesOfType (LitTy {})           = emptyNameSet
@@ -1963,7 +1962,7 @@ sizeType, size_type :: Type -> TypeSize
 sizeType ty | isKind ty = 0
             | otherwise = size_type ty
 
 sizeType ty | isKind ty = 0
             | otherwise = size_type ty
 
-size_type ty | Just exp_ty <- tcView ty = size_type exp_ty
+size_type ty | Just exp_ty <- coreView ty = size_type exp_ty
 size_type (TyVarTy {})      = 1
 size_type (TyConApp tc tys)
   | isTypeFamilyTyCon tc   = infinity  -- Type-family applications can
 size_type (TyVarTy {})      = 1
 size_type (TyConApp tc tys)
   | isTypeFamilyTyCon tc   = infinity  -- Type-family applications can
index 18278ab..6754cb5 100644 (file)
@@ -130,7 +130,7 @@ matchExpectedFunTys herald arity orig_ty
       | n_req == 0 = return (mkTcNomReflCo ty, [], ty)
 
     go n_req ty
       | n_req == 0 = return (mkTcNomReflCo ty, [], ty)
 
     go n_req ty
-      | Just ty' <- tcView ty = go n_req ty'
+      | Just ty' <- coreView ty = go n_req ty'
 
     go n_req (FunTy arg_ty res_ty)
       | not (isPredTy arg_ty)
 
     go n_req (FunTy arg_ty res_ty)
       | not (isPredTy arg_ty)
@@ -234,7 +234,7 @@ matchExpectedTyConApp tc orig_ty
   = go orig_ty
   where
     go ty
   = go orig_ty
   where
     go ty
-       | Just ty' <- tcView ty
+       | Just ty' <- coreView ty
        = go ty'
 
     go ty@(TyConApp tycon args)
        = go ty'
 
     go ty@(TyConApp tycon args)
@@ -281,7 +281,7 @@ matchExpectedAppTy orig_ty
   = go orig_ty
   where
     go ty
   = go orig_ty
   where
     go ty
-      | Just ty' <- tcView ty = go ty'
+      | Just ty' <- coreView ty = go ty'
 
       | Just (fun_ty, arg_ty) <- tcSplitAppTy_maybe ty
       = return (mkTcNomReflCo orig_ty, (fun_ty, arg_ty))
 
       | Just (fun_ty, arg_ty) <- tcSplitAppTy_maybe ty
       = return (mkTcNomReflCo orig_ty, (fun_ty, arg_ty))
@@ -745,8 +745,8 @@ uType origin orig_ty1 orig_ty2
         -- we'll end up saying "can't match Foo with Bool"
         -- rather than "can't match "Int with Bool".  See Trac #4535.
     go ty1 ty2
         -- we'll end up saying "can't match Foo with Bool"
         -- rather than "can't match "Int with Bool".  See Trac #4535.
     go ty1 ty2
-      | Just ty1' <- tcView ty1 = go ty1' ty2
-      | Just ty2' <- tcView ty2 = go ty1  ty2'
+      | Just ty1' <- coreView ty1 = go ty1' ty2
+      | Just ty2' <- coreView ty2 = go ty1  ty2'
 
         -- Functions (or predicate functions) just check the two parts
     go (FunTy fun1 arg1) (FunTy fun2 arg2)
 
         -- Functions (or predicate functions) just check the two parts
     go (FunTy fun1 arg1) (FunTy fun2 arg2)
@@ -1263,8 +1263,8 @@ unifyKindX (TyVarTy kv1) k2 = uKVar NotSwapped unifyKindX kv1 k2
 unifyKindX k1 (TyVarTy kv2) = uKVar IsSwapped  unifyKindX kv2 k1
 
 unifyKindX k1 k2       -- See Note [Expanding synonyms during unification]
 unifyKindX k1 (TyVarTy kv2) = uKVar IsSwapped  unifyKindX kv2 k1
 
 unifyKindX k1 k2       -- See Note [Expanding synonyms during unification]
-  | Just k1' <- tcView k1 = unifyKindX k1' k2
-  | Just k2' <- tcView k2 = unifyKindX k1  k2'
+  | Just k1' <- coreView k1 = unifyKindX k1' k2
+  | Just k2' <- coreView k2 = unifyKindX k1  k2'
 
 unifyKindX (TyConApp kc1 []) (TyConApp kc2 [])
   | kc1 == kc2               = return (Just EQ)
 
 unifyKindX (TyConApp kc1 []) (TyConApp kc2 [])
   | kc1 == kc2               = return (Just EQ)
index 8422ba4..75da391 100644 (file)
@@ -494,7 +494,7 @@ check_syn_tc_app ctxt rank ty tc tys
                 mapM_ check_arg tys
 
           else  -- In the liberal case (only for closed syns), expand then check
                 mapM_ check_arg tys
 
           else  -- In the liberal case (only for closed syns), expand then check
-          case tcView ty of
+          case coreView ty of
              Just ty' -> check_type ctxt rank ty'
              Nothing  -> pprPanic "check_tau_type" (ppr ty)  }
 
              Just ty' -> check_type ctxt rank ty'
              Nothing  -> pprPanic "check_tau_type" (ppr ty)  }
 
@@ -1447,7 +1447,7 @@ fvType, fv_type :: Type -> [TyVar]
 fvType ty | isKind ty = []
           | otherwise = fv_type ty
 
 fvType ty | isKind ty = []
           | otherwise = fv_type ty
 
-fv_type ty | Just exp_ty <- tcView ty = fv_type exp_ty
+fv_type ty | Just exp_ty <- coreView ty = fv_type exp_ty
 fv_type (TyVarTy tv)        = [tv]
 fv_type (TyConApp _ tys)    = fvTypes tys
 fv_type (LitTy {})          = []
 fv_type (TyVarTy tv)        = [tv]
 fv_type (TyConApp _ tys)    = fvTypes tys
 fv_type (LitTy {})          = []
index f7493f3..78c1670 100644 (file)
@@ -100,7 +100,7 @@ module Type (
         seqType, seqTypes,
 
         -- * Other views onto Types
         seqType, seqTypes,
 
         -- * Other views onto Types
-        coreView, tcView,
+        coreView,
 
         UnaryType, RepType(..), flattenRepType, repType,
         tyConsOfType,
 
         UnaryType, RepType(..), flattenRepType, repType,
         tyConsOfType,
@@ -270,16 +270,6 @@ coreView (TyConApp tc tys) | Just (tenv, rhs, tys') <- expandSynTyCon_maybe tc t
 coreView _ = Nothing
 
 -----------------------------------------------
 coreView _ = Nothing
 
 -----------------------------------------------
-{-# INLINE tcView #-}
-tcView :: Type -> Maybe Type
--- ^ Historical only; 'tcView' and 'coreView' used to differ, but don't any more
-tcView = coreView
-  -- ToDo: get rid of tcView altogether
-  -- You might think that tcView belows in TcType rather than Type, but unfortunately
-  -- it is needed by Unify, which is turn imported by Coercion (for MatchEnv and matchList).
-  -- So we will leave it here to avoid module loops.
-
------------------------------------------------
 expandTypeSynonyms :: Type -> Type
 -- ^ Expand out all type synonyms.  Actually, it'd suffice to expand out
 -- just the ones that discard type variables (e.g.  type Funny a = Int)
 expandTypeSynonyms :: Type -> Type
 -- ^ Expand out all type synonyms.  Actually, it'd suffice to expand out
 -- just the ones that discard type variables (e.g.  type Funny a = Int)
@@ -444,7 +434,7 @@ mkNumLitTy n = LitTy (NumTyLit n)
 
 -- | Is this a numeric literal. We also look through type synonyms.
 isNumLitTy :: Type -> Maybe Integer
 
 -- | Is this a numeric literal. We also look through type synonyms.
 isNumLitTy :: Type -> Maybe Integer
-isNumLitTy ty | Just ty1 <- tcView ty = isNumLitTy ty1
+isNumLitTy ty | Just ty1 <- coreView ty = isNumLitTy ty1
 isNumLitTy (LitTy (NumTyLit n)) = Just n
 isNumLitTy _                    = Nothing
 
 isNumLitTy (LitTy (NumTyLit n)) = Just n
 isNumLitTy _                    = Nothing
 
@@ -453,7 +443,7 @@ mkStrLitTy s = LitTy (StrTyLit s)
 
 -- | Is this a symbol literal. We also look through type synonyms.
 isStrLitTy :: Type -> Maybe FastString
 
 -- | Is this a symbol literal. We also look through type synonyms.
 isStrLitTy :: Type -> Maybe FastString
-isStrLitTy ty | Just ty1 <- tcView ty = isStrLitTy ty1
+isStrLitTy ty | Just ty1 <- coreView ty = isStrLitTy ty1
 isStrLitTy (LitTy (StrTyLit s)) = Just s
 isStrLitTy _                    = Nothing
 
 isStrLitTy (LitTy (StrTyLit s)) = Just s
 isStrLitTy _                    = Nothing
 
@@ -755,7 +745,7 @@ tyConsOfType ty
   = go ty
   where
      go :: Type -> NameEnv TyCon  -- The NameEnv does duplicate elim
   = go ty
   where
      go :: Type -> NameEnv TyCon  -- The NameEnv does duplicate elim
-     go ty | Just ty' <- tcView ty = go ty'
+     go ty | Just ty' <- coreView ty = go ty'
      go (TyVarTy {})               = emptyNameEnv
      go (LitTy {})                 = emptyNameEnv
      go (TyConApp tc tys)          = go_tc tc tys
      go (TyVarTy {})               = emptyNameEnv
      go (LitTy {})                 = emptyNameEnv
      go (TyConApp tc tys)          = go_tc tc tys
index e876b2e..78e4936 100644 (file)
@@ -207,7 +207,7 @@ match menv subst (FunTy ty1a ty1b) (FunTy ty2a ty2b)
        ; match menv subst' ty1b ty2b }
 match menv subst (AppTy ty1a ty1b) ty2
   | Just (ty2a, ty2b) <- repSplitAppTy_maybe ty2
        ; match menv subst' ty1b ty2b }
 match menv subst (AppTy ty1a ty1b) ty2
   | Just (ty2a, ty2b) <- repSplitAppTy_maybe ty2
-        -- 'repSplit' used because the tcView stuff is done above
+        -- 'repSplit' used because the coreView stuff is done above
   = do { subst' <- match menv subst ty1a ty2a
        ; match menv subst' ty1b ty2b }
 
   = do { subst' <- match menv subst ty1a ty2a
        ; match menv subst' ty1b ty2b }
 
@@ -406,8 +406,8 @@ tcUnifyTyWithTFs twoWay t1 t2 = niFixTvSubst `fmap` go t1 t2 emptyTvSubstEnv
     where
       go :: Type -> Type -> TvSubstEnv -> Maybe TvSubstEnv
       -- look through type synonyms
     where
       go :: Type -> Type -> TvSubstEnv -> Maybe TvSubstEnv
       -- look through type synonyms
-      go t1 t2 theta | Just t1' <- tcView t1 = go t1' t2  theta
-      go t1 t2 theta | Just t2' <- tcView t2 = go t1  t2' theta
+      go t1 t2 theta | Just t1' <- coreView t1 = go t1' t2  theta
+      go t1 t2 theta | Just t2' <- coreView t2 = go t1  t2' theta
       -- proper unification
       go (TyVarTy tv) t2 theta
           -- Equation (1)
       -- proper unification
       go (TyVarTy tv) t2 theta
           -- Equation (1)
@@ -571,8 +571,8 @@ unify :: Type -> Type -> UM ()
 unify (TyVarTy tv1) ty2  = uVar tv1 ty2
 unify ty1 (TyVarTy tv2)  = uVar tv2 ty1
 
 unify (TyVarTy tv1) ty2  = uVar tv1 ty2
 unify ty1 (TyVarTy tv2)  = uVar tv2 ty1
 
-unify ty1 ty2 | Just ty1' <- tcView ty1 = unify ty1' ty2
-unify ty1 ty2 | Just ty2' <- tcView ty2 = unify ty1 ty2'
+unify ty1 ty2 | Just ty1' <- coreView ty1 = unify ty1' ty2
+unify ty1 ty2 | Just ty2' <- coreView ty2 = unify ty1 ty2'
 
 unify ty1 ty2
   | Just (tc1, tys1) <- splitTyConApp_maybe ty1
 
 unify ty1 ty2
   | Just (tc1, tys1) <- splitTyConApp_maybe ty1
@@ -636,7 +636,7 @@ uUnrefined :: TvSubstEnv          -- environment to extend (from the UM monad)
 -- We know that tv1 isn't refined
 
 uUnrefined subst tv1 ty2 ty2'
 -- We know that tv1 isn't refined
 
 uUnrefined subst tv1 ty2 ty2'
-  | Just ty2'' <- tcView ty2'
+  | Just ty2'' <- coreView ty2'
   = uUnrefined subst tv1 ty2 ty2''      -- Unwrap synonyms
                 -- This is essential, in case we have
                 --      type Foo a = a
   = uUnrefined subst tv1 ty2 ty2''      -- Unwrap synonyms
                 -- This is essential, in case we have
                 --      type Foo a = a