Tabs -> spaces
authorManuel M T Chakravarty <chak@cse.unsw.edu.au>
Thu, 27 Oct 2011 23:31:51 +0000 (10:31 +1100)
committerManuel M T Chakravarty <chak@cse.unsw.edu.au>
Mon, 31 Oct 2011 08:50:40 +0000 (19:50 +1100)
compiler/typecheck/TcEnv.lhs

index e271d09..d4713a7 100644 (file)
@@ -4,49 +4,49 @@
 
 \begin{code}
 module TcEnv(
-       TyThing(..), TcTyThing(..), TcId,
+        TyThing(..), TcTyThing(..), TcId,
 
-       -- Instance environment, and InstInfo type
-       InstInfo(..), iDFunId, pprInstInfo, pprInstInfoDetails,
-       simpleInstInfoClsTy, simpleInstInfoTy, simpleInstInfoTyCon, 
-       InstBindings(..),
+        -- Instance environment, and InstInfo type
+        InstInfo(..), iDFunId, pprInstInfo, pprInstInfoDetails,
+        simpleInstInfoClsTy, simpleInstInfoTy, simpleInstInfoTyCon, 
+        InstBindings(..),
 
-       -- Global environment
+        -- Global environment
         tcExtendGlobalEnv, tcExtendGlobalEnvImplicit, setGlobalTypeEnv,
-       tcExtendGlobalValEnv,
-       tcLookupLocatedGlobal,  tcLookupGlobal, 
-       tcLookupField, tcLookupTyCon, tcLookupClass, tcLookupDataCon,
-       tcLookupLocatedGlobalId, tcLookupLocatedTyCon,
-       tcLookupLocatedClass, 
-       
-       -- Local environment
-       tcExtendKindEnv, tcExtendKindEnvTvs,
-       tcExtendTyVarEnv, tcExtendTyVarEnv2, 
-       tcExtendGhciEnv, tcExtendLetEnv,
-       tcExtendIdEnv, tcExtendIdEnv1, tcExtendIdEnv2, 
-       tcLookup, tcLookupLocated, tcLookupLocalIds, 
-       tcLookupId, tcLookupTyVar, getScopedTyVarBinds,
-       getInLocalScope,
-       wrongThingErr, pprBinders,
-
-       tcExtendRecEnv,         -- For knot-tying
-
-       -- Rules
-       tcExtendRules,
-
-       -- Defaults
-       tcGetDefaultTys,
-
-       -- Global type variables
-       tcGetGlobalTyVars,
-
-       -- Template Haskell stuff
-       checkWellStaged, tcMetaTy, thLevel, 
-       topIdLvl, thTopLevelId, thRnBrack, isBrackStage,
-
-       -- New Ids
-       newLocalName, newDFunName, newFamInstTyConName, 
-       mkStableIdFromString, mkStableIdFromName
+        tcExtendGlobalValEnv,
+        tcLookupLocatedGlobal,  tcLookupGlobal, 
+        tcLookupField, tcLookupTyCon, tcLookupClass, tcLookupDataCon,
+        tcLookupLocatedGlobalId, tcLookupLocatedTyCon,
+        tcLookupLocatedClass, 
+        
+        -- Local environment
+        tcExtendKindEnv, tcExtendKindEnvTvs,
+        tcExtendTyVarEnv, tcExtendTyVarEnv2, 
+        tcExtendGhciEnv, tcExtendLetEnv,
+        tcExtendIdEnv, tcExtendIdEnv1, tcExtendIdEnv2, 
+        tcLookup, tcLookupLocated, tcLookupLocalIds, 
+        tcLookupId, tcLookupTyVar, getScopedTyVarBinds,
+        getInLocalScope,
+        wrongThingErr, pprBinders,
+
+        tcExtendRecEnv,         -- For knot-tying
+
+        -- Rules
+        tcExtendRules,
+
+        -- Defaults
+        tcGetDefaultTys,
+
+        -- Global type variables
+        tcGetGlobalTyVars,
+
+        -- Template Haskell stuff
+        checkWellStaged, tcMetaTy, thLevel, 
+        topIdLvl, thTopLevelId, thRnBrack, isBrackStage,
+
+        -- New Ids
+        newLocalName, newDFunName, newFamInstTyConName, 
+        mkStableIdFromString, mkStableIdFromName
   ) where
 
 #include "HsVersions.h"
@@ -56,7 +56,7 @@ import IfaceEnv
 import TcRnMonad
 import TcMType
 import TcType
-import TcIface 
+import TcIface  
 import PrelNames
 import TysWiredIn
 import Id
@@ -82,9 +82,9 @@ import FastString
 
 
 %************************************************************************
-%*                                                                     *
-%*                     tcLookupGlobal                                  *
-%*                                                                     *
+%*                                                                      *
+%*                      tcLookupGlobal                                  *
+%*                                                                      *
 %************************************************************************
 
 Using the Located versions (eg. tcLookupLocatedGlobal) is preferred,
@@ -102,42 +102,42 @@ tcLookupGlobal :: Name -> TcM TyThing
 -- In GHCi, we may make command-line bindings (ghci> let x = True)
 -- that bind a GlobalId, but with an InternalName
 tcLookupGlobal name
-  = do { env <- getGblEnv
-       
-               -- Try local envt
-       ; case lookupNameEnv (tcg_type_env env) name of { 
-               Just thing -> return thing ;
-               Nothing    -> do 
-        
-               -- Try global envt
-       { hsc_env <- getTopEnv
+  = do  { env <- getGblEnv
+        
+                -- Try local envt
+        ; case lookupNameEnv (tcg_type_env env) name of { 
+                Just thing -> return thing ;
+                Nothing    -> do 
+         
+                -- Try global envt
+        { hsc_env <- getTopEnv
         ; mb_thing <- liftIO (lookupTypeHscEnv hsc_env name)
-       ; case mb_thing of  {
-           Just thing -> return thing ;
-           Nothing    -> do
+        ; case mb_thing of  {
+            Just thing -> return thing ;
+            Nothing    -> do
 
-               -- Should it have been in the local envt?
-       { case nameModule_maybe name of
-               Nothing -> notFound name -- Internal names can happen in GHCi
+                -- Should it have been in the local envt?
+        { 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
-                        | otherwise
-                        -> tcImportDecl name   -- Go find it in an interface
-       }}}}}
+                Just mod | mod == tcg_mod env   -- Names from this module 
+                         -> notFound name -- should be in tcg_type_env
+                         | otherwise
+                         -> tcImportDecl name   -- Go find it in an interface
+        }}}}}
 
-tcLookupField :: Name -> TcM Id                -- Returns the selector Id
+tcLookupField :: Name -> TcM Id         -- Returns the selector Id
 tcLookupField name 
-  = tcLookupId name    -- Note [Record field lookup]
+  = tcLookupId name     -- Note [Record field lookup]
 
 {- Note [Record field lookup]
    ~~~~~~~~~~~~~~~~~~~~~~~~~~
 You might think we should have tcLookupGlobal here, since record fields
 are always top level.  But consider
-       f = e { f = True }
+        f = e { f = True }
 Then the renamer (which does not keep track of what is a record selector
 and what is not) will rename the definition thus
-       f_7 = e { f_7 = True }
+        f_7 = e { f_7 = True }
 Now the type checker will find f_7 in the *local* type environment, not
 the global (imported) one. It's wrong, of course, but we want to report a tidy
 error, not in TcEnv.notFound.  -}
@@ -146,22 +146,22 @@ tcLookupDataCon :: Name -> TcM DataCon
 tcLookupDataCon name = do
     thing <- tcLookupGlobal name
     case thing of
-       ADataCon con -> return con
-       _            -> wrongThingErr "data constructor" (AGlobal thing) name
+        ADataCon con -> return con
+        _            -> wrongThingErr "data constructor" (AGlobal thing) name
 
 tcLookupClass :: Name -> TcM Class
 tcLookupClass name = do
     thing <- tcLookupGlobal name
     case thing of
-       ATyCon tc | Just cls <- tyConClass_maybe tc -> return cls
-       _                                           -> wrongThingErr "class" (AGlobal thing) name
+        ATyCon tc | Just cls <- tyConClass_maybe tc -> return cls
+        _                                           -> wrongThingErr "class" (AGlobal thing) name
 
 tcLookupTyCon :: Name -> TcM TyCon
 tcLookupTyCon name = do
     thing <- tcLookupGlobal name
     case thing of
-       ATyCon tc -> return tc
-       _         -> wrongThingErr "type constructor" (AGlobal thing) name
+        ATyCon tc -> return tc
+        _         -> wrongThingErr "type constructor" (AGlobal thing) name
 
 tcLookupLocatedGlobalId :: Located Name -> TcM Id
 tcLookupLocatedGlobalId = addLocM tcLookupId
@@ -179,9 +179,9 @@ instance MonadThings (IOEnv (Env TcGblEnv TcLclEnv)) where
 \end{code}
 
 %************************************************************************
-%*                                                                     *
-               Extending the global environment
-%*                                                                     *
+%*                                                                      *
+                Extending the global environment
+%*                                                                      *
 %************************************************************************
 
 
@@ -189,11 +189,11 @@ instance MonadThings (IOEnv (Env TcGblEnv TcLclEnv)) where
 setGlobalTypeEnv :: TcGblEnv -> TypeEnv -> TcM TcGblEnv
 -- Use this to update the global type env 
 -- It updates both  * the normal tcg_type_env field
---                 * the tcg_type_env_var field seen by interface files
+--                  * the tcg_type_env_var field seen by interface files
 setGlobalTypeEnv tcg_env new_type_env
   = do  {     -- Sync the type-envt variable seen by interface files
-          writeMutVar (tcg_type_env_var tcg_env) new_type_env
-        ; return (tcg_env { tcg_type_env = new_type_env }) }
+           writeMutVar (tcg_type_env_var tcg_env) new_type_env
+         ; return (tcg_env { tcg_type_env = new_type_env }) }
 
 
 tcExtendGlobalEnv :: [TyThing] -> TcM r -> TcM r
@@ -217,10 +217,10 @@ tcExtendGlobalEnvImplicit :: [TyThing] -> TcM r -> TcM r
   -- are dfuns, famInstTyCons, data cons, etc.
   -- These TyThings are not added to tcg_tcs or tcg_clss.
 tcExtendGlobalEnvImplicit things thing_inside
-   = do        { tcg_env <- getGblEnv
-       ; let ge'  = extendTypeEnvList (tcg_type_env tcg_env) things
-       ; tcg_env' <- setGlobalTypeEnv tcg_env ge'
-       ; setGblEnv tcg_env' thing_inside }
+   = do { tcg_env <- getGblEnv
+        ; let ge'  = extendTypeEnvList (tcg_type_env tcg_env) things
+        ; tcg_env' <- setGlobalTypeEnv tcg_env ge'
+        ; setGblEnv tcg_env' thing_inside }
 
 tcExtendGlobalValEnv :: [Id] -> TcM a -> TcM a
   -- Same deal as tcExtendGlobalEnv, but for Ids
@@ -239,9 +239,9 @@ tcExtendRecEnv gbl_stuff thing_inside
 
 
 %************************************************************************
-%*                                                                     *
+%*                                                                      *
 \subsection{The local environment}
-%*                                                                     *
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -252,15 +252,15 @@ tcLookup :: Name -> TcM TcTyThing
 tcLookup name = do
     local_env <- getLclTypeEnv
     case lookupNameEnv local_env name of
-       Just thing -> return thing
-       Nothing    -> AGlobal <$> tcLookupGlobal name
+        Just thing -> return thing
+        Nothing    -> AGlobal <$> tcLookupGlobal name
 
 tcLookupTyVar :: Name -> TcM TcTyVar
 tcLookupTyVar name = do
     thing <- tcLookup name
     case thing of
-       ATyVar _ ty -> return (tcGetTyVar "tcLookupTyVar" ty)
-       _           -> pprPanic "tcLookupTyVar" (ppr name)
+        ATyVar _ ty -> return (tcGetTyVar "tcLookupTyVar" ty)
+        _           -> pprPanic "tcLookupTyVar" (ppr name)
 
 tcLookupId :: Name -> TcM Id
 -- Used when we aren't interested in the binding level, nor refinement. 
@@ -282,10 +282,10 @@ tcLookupLocalIds ns = do
     return (map (lookup (tcl_env env) (thLevel (tcl_th_ctxt env))) ns)
   where
     lookup lenv lvl name 
-       = case lookupNameEnv lenv name of
-               Just (ATcId { tct_id = id, tct_level = lvl1 }) 
-                       -> ASSERT( lvl == lvl1 ) id
-               _ -> pprPanic "tcLookupLocalIds" (ppr name)
+        = case lookupNameEnv lenv name of
+                Just (ATcId { tct_id = id, tct_level = lvl1 }) 
+                        -> ASSERT( lvl == lvl1 ) id
+                _ -> pprPanic "tcLookupLocalIds" (ppr name)
 
 getInLocalScope :: TcM (Name -> Bool)
   -- Ids only
@@ -316,19 +316,19 @@ tcExtendTyVarEnv2 binds thing_inside
 
 getScopedTyVarBinds :: TcM [(Name, TcType)]
 getScopedTyVarBinds
-  = do { lcl_env <- getLclEnv
-       ; return [(name, ty) | ATyVar name ty <- nameEnvElts (tcl_env lcl_env)] }
+  = do  { lcl_env <- getLclEnv
+        ; return [(name, ty) | ATyVar name ty <- nameEnvElts (tcl_env lcl_env)] }
 \end{code}
 
 
 \begin{code}
 tcExtendLetEnv :: TopLevelFlag -> [TcId] -> TcM a -> TcM a
 tcExtendLetEnv closed ids thing_inside 
-  = do { stage <- getStage
-       ; tc_extend_local_env [ (idName id, ATcId { tct_id = id 
-                                                 , tct_closed = closed
-                                                 , tct_level = thLevel stage })
-                                | id <- ids]
+  = do  { stage <- getStage
+        ; tc_extend_local_env [ (idName id, ATcId { tct_id = id 
+                                                  , tct_closed = closed
+                                                  , tct_level = thLevel stage })
+                                 | id <- ids]
           thing_inside }
 
 tcExtendIdEnv :: [TcId] -> TcM a -> TcM a
@@ -342,11 +342,11 @@ tcExtendIdEnv1 name id thing_inside
 tcExtendIdEnv2 :: [(Name,TcId)] -> TcM a -> TcM a
 -- Invariant: the TcIds are fully zonked (see tcExtendIdEnv above)
 tcExtendIdEnv2 names_w_ids thing_inside
-  = do { stage <- getStage
-       ; tc_extend_local_env [ (name, ATcId { tct_id = id 
-                                            , tct_closed = NotTopLevel
-                                            , tct_level = thLevel stage })
-                                | (name,id) <- names_w_ids]
+  = do  { stage <- getStage
+        ; tc_extend_local_env [ (name, ATcId { tct_id = id 
+                                             , tct_closed = NotTopLevel
+                                             , tct_level = thLevel stage })
+                                 | (name,id) <- names_w_ids]
           thing_inside }
 
 tcExtendGhciEnv :: [TcId] -> TcM a -> TcM a
@@ -359,8 +359,8 @@ tcExtendGhciEnv :: [TcId] -> TcM a -> TcM a
 
 tcExtendGhciEnv ids thing_inside
   = tc_extend_local_env [ (idName id, ATcId { tct_id     = id 
-                                           , tct_closed = is_top id
-                                           , tct_level  = impLevel })
+                                            , tct_closed = is_top id
+                                            , tct_level  = impLevel })
                         | id <- ids]
     thing_inside
   where
@@ -371,20 +371,20 @@ tcExtendGhciEnv ids thing_inside
 tc_extend_local_env :: [(Name, TcTyThing)] -> TcM a -> TcM a
 -- This is the guy who does the work
 -- Invariant: the TcIds are fully zonked. Reasons:
---     (a) The kinds of the forall'd type variables are defaulted
---         (see Kind.defaultKind, done in zonkQuantifiedTyVar)
---     (b) There are no via-Indirect occurrences of the bound variables
---         in the types, because instantiation does not look through such things
---     (c) The call to tyVarsOfTypes is ok without looking through refs
+--      (a) The kinds of the forall'd type variables are defaulted
+--          (see Kind.defaultKind, done in zonkQuantifiedTyVar)
+--      (b) There are no via-Indirect occurrences of the bound variables
+--          in the types, because instantiation does not look through such things
+--      (c) The call to tyVarsOfTypes is ok without looking through refs
 
 tc_extend_local_env extra_env thing_inside
-  = do { traceTc "env2" (ppr extra_env)
+  = do  { traceTc "env2" (ppr extra_env)
         ; env1 <- getLclEnv
         ; let le'      = extendNameEnvList     (tcl_env env1) extra_env
               rdr_env' = extendLocalRdrEnvList (tcl_rdr env1) (map fst extra_env)
-             env2     = env1 {tcl_env = le', tcl_rdr = rdr_env'}
-       ; env3 <- extend_gtvs env2
-       ; setLclEnv env3 thing_inside }
+              env2     = env1 {tcl_env = le', tcl_rdr = rdr_env'}
+        ; env3 <- extend_gtvs env2
+        ; setLclEnv env3 thing_inside }
   where
     extend_gtvs env 
       | isEmptyVarSet extra_tvs 
@@ -402,16 +402,16 @@ tc_extend_local_env extra_env thing_inside
           NotTopLevel -> id_tvs
       where
         id_tvs = tcTyVarsOfType (idType id)
-    get_tvs (_, ATyVar _ ty) = tcTyVarsOfType ty       -- See Note [Global TyVars]
+    get_tvs (_, ATyVar _ ty) = tcTyVarsOfType ty        -- See Note [Global TyVars]
     get_tvs other = pprPanic "get_tvs" (ppr other)
         
-       -- Note [Global TyVars]
-       -- It's important to add the in-scope tyvars to the global tyvar set
-       -- as well.  Consider
-       --      f (_::r) = let g y = y::r in ...
-       -- Here, g mustn't be generalised.  This is also important during
-       -- class and instance decls, when we mustn't generalise the class tyvars
-       -- when typechecking the methods.
+        -- Note [Global TyVars]
+        -- It's important to add the in-scope tyvars to the global tyvar set
+        -- as well.  Consider
+        --      f (_::r) = let g y = y::r in ...
+        -- Here, g mustn't be generalised.  This is also important during
+        -- class and instance decls, when we mustn't generalise the class tyvars
+        -- when typechecking the methods.
 
 tcExtendGlobalTyVars :: IORef VarSet -> VarSet -> TcM (IORef VarSet)
 tcExtendGlobalTyVars gtv_var extra_global_tvs
@@ -421,51 +421,51 @@ tcExtendGlobalTyVars gtv_var extra_global_tvs
 
 
 %************************************************************************
-%*                                                                     *
+%*                                                                      *
 \subsection{Rules}
-%*                                                                     *
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
 tcExtendRules :: [LRuleDecl Id] -> TcM a -> TcM a
-       -- Just pop the new rules into the EPS and envt resp
-       -- All the rules come from an interface file, not source
-       -- Nevertheless, some may be for this module, if we read
-       -- its interface instead of its source code
+        -- Just pop the new rules into the EPS and envt resp
+        -- All the rules come from an interface file, not source
+        -- Nevertheless, some may be for this module, if we read
+        -- its interface instead of its source code
 tcExtendRules lcl_rules thing_inside
  = do { env <- getGblEnv
       ; let
-         env' = env { tcg_rules = lcl_rules ++ tcg_rules env }
+          env' = env { tcg_rules = lcl_rules ++ tcg_rules env }
       ; setGblEnv env' thing_inside }
 \end{code}
 
 
 %************************************************************************
-%*                                                                     *
-               Meta level
-%*                                                                     *
+%*                                                                      *
+                Meta level
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
-checkWellStaged :: SDoc                -- What the stage check is for
-               -> ThLevel      -- Binding level (increases inside brackets)
-               -> ThLevel      -- Use stage
-               -> TcM ()       -- Fail if badly staged, adding an error
+checkWellStaged :: SDoc         -- What the stage check is for
+                -> ThLevel      -- Binding level (increases inside brackets)
+                -> ThLevel      -- Use stage
+                -> TcM ()       -- Fail if badly staged, adding an error
 checkWellStaged pp_thing bind_lvl use_lvl
-  | use_lvl >= bind_lvl        -- OK! Used later than bound
-  = return ()                  -- E.g.  \x -> [| $(f x) |]
+  | use_lvl >= bind_lvl         -- OK! Used later than bound
+  = return ()                   -- E.g.  \x -> [| $(f x) |]
 
-  | bind_lvl == outerLevel     -- GHC restriction on top level splices
+  | bind_lvl == outerLevel      -- GHC restriction on top level splices
   = failWithTc $ 
     sep [ptext (sLit "GHC stage restriction:") <+>  pp_thing,
-        nest 2 (vcat [ ptext (sLit "is used in a top-level splice or annotation,")
+         nest 2 (vcat [ ptext (sLit "is used in a top-level splice or annotation,")
                       , ptext (sLit "and must be imported, not defined locally")])]
 
-  | otherwise                  -- Badly staged
-  = failWithTc $               -- E.g.  \x -> $(f x)
+  | otherwise                   -- Badly staged
+  = failWithTc $                -- E.g.  \x -> $(f x)
     ptext (sLit "Stage error:") <+> pp_thing <+> 
-       hsep   [ptext (sLit "is bound at stage") <+> ppr bind_lvl,
-               ptext (sLit "but used at stage") <+> ppr use_lvl]
+        hsep   [ptext (sLit "is bound at stage") <+> ppr bind_lvl,
+                ptext (sLit "but used at stage") <+> ppr use_lvl]
 
 topIdLvl :: Id -> ThLevel
 -- Globals may either be imported, or may be from an earlier "chunk" 
@@ -473,12 +473,12 @@ topIdLvl :: Id -> ThLevel
 --  *can* be used inside a top-level splice, but the latter cannot.
 -- Hence we give the former impLevel, but the latter topLevel
 -- E.g. this is bad:
---     x = [| foo |]
---     $( f x )
+--      x = [| foo |]
+--      $( f x )
 -- By the time we are prcessing the $(f x), the binding for "x" 
 -- will be in the global env, not the local one.
 topIdLvl id | isLocalId id = outerLevel
-           | otherwise    = impLevel
+            | otherwise    = impLevel
 
 tcMetaTy :: Name -> TcM Type
 -- Given the name of a Template Haskell data type, 
@@ -505,38 +505,38 @@ thTopLevelId id = isGlobalId id || isExternalName (idName id)
 
 
 %************************************************************************
-%*                                                                     *
-                 getDefaultTys                                                                         
-%*                                                                     *
+%*                                                                      *
+                 getDefaultTys                                                                          
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
-tcGetDefaultTys :: Bool                -- True <=> interactive context
+tcGetDefaultTys :: Bool         -- True <=> interactive context
                 -> TcM ([Type], -- Default types
-                        (Bool, -- True <=> Use overloaded strings
+                        (Bool,  -- True <=> Use overloaded strings
                          Bool)) -- True <=> Use extended defaulting rules
 tcGetDefaultTys interactive
-  = do { dflags <- getDOpts
+  = do  { dflags <- getDOpts
         ; let ovl_strings = xopt Opt_OverloadedStrings dflags
               extended_defaults = interactive
                                || xopt Opt_ExtendedDefaultRules dflags
-                                       -- See also Trac #1974 
+                                        -- See also Trac #1974 
               flags = (ovl_strings, extended_defaults)
     
         ; mb_defaults <- getDeclaredDefaultTys
-       ; case mb_defaults of {
-          Just tys -> return (tys, flags) ;
-                               -- User-supplied defaults
-          Nothing  -> do
-
-       -- No use-supplied default
-       -- Use [Integer, Double], plus modifications
-       { integer_ty <- tcMetaTy integerTyConName
-       ; checkWiredInTyCon doubleTyCon
-       ; string_ty <- tcMetaTy stringTyConName
+        ; case mb_defaults of {
+           Just tys -> return (tys, flags) ;
+                                -- User-supplied defaults
+           Nothing  -> do
+
+        -- No use-supplied default
+        -- Use [Integer, Double], plus modifications
+        { integer_ty <- tcMetaTy integerTyConName
+        ; checkWiredInTyCon doubleTyCon
+        ; string_ty <- tcMetaTy stringTyConName
         ; let deflt_tys = opt_deflt extended_defaults unitTy  -- Note [Default unitTy]
-                         ++ [integer_ty, doubleTy]
-                         ++ opt_deflt ovl_strings string_ty
+                          ++ [integer_ty, doubleTy]
+                          ++ opt_deflt ovl_strings string_ty
         ; return (deflt_tys, flags) } } }
   where
     opt_deflt True  ty = [ty]
@@ -548,7 +548,7 @@ Note [Default unitTy]
 In interative mode (or with -XExtendedDefaultRules) we add () as the first type we
 try when defaulting.  This has very little real impact, except in the following case.
 Consider: 
-       Text.Printf.printf "hello"
+        Text.Printf.printf "hello"
 This has type (forall a. IO a); it prints "hello", and returns 'undefined'.  We don't
 want the GHCi repl loop to try to print that 'undefined'.  The neatest thing is to
 default the 'a' to (), rather than to Integer (which is what would otherwise happen;
@@ -557,9 +557,9 @@ and then GHCi doesn't attempt to print the ().  So in interactive mode, we add
 
 
 %************************************************************************
-%*                                                                     *
+%*                                                                      *
 \subsection{The InstInfo type}
-%*                                                                     *
+%*                                                                      *
 %************************************************************************
 
 The InstInfo type summarises the information in an instance declaration
@@ -568,8 +568,8 @@ The InstInfo type summarises the information in an instance declaration
 
 It is used just for *local* instance decls (not ones from interface files).
 But local instance decls includes
-       - derived ones
-       - generic ones
+        - derived ones
+        - generic ones
 as well as explicit user written ones.
 
 \begin{code}
@@ -583,26 +583,26 @@ iDFunId :: InstInfo a -> DFunId
 iDFunId info = instanceDFunId (iSpec info)
 
 data InstBindings a
-  = VanillaInst                -- The normal case
-       (LHsBinds a)            -- Bindings for the instance methods
-       [LSig a]                -- User pragmas recorded for generating 
-                               -- specialised instances
-       Bool                    -- True <=> This code came from a standalone deriving clause
+  = VanillaInst                 -- The normal case
+        (LHsBinds a)            -- Bindings for the instance methods
+        [LSig a]                -- User pragmas recorded for generating 
+                                -- specialised instances
+        Bool                    -- True <=> This code came from a standalone deriving clause
                                 --          Used only to improve error messages
 
   | NewTypeDerived      -- Used for deriving instances of newtypes, where the
-                       -- witness dictionary is identical to the argument 
-                       -- dictionary.  Hence no bindings, no pragmas.
-
-       Coercion        -- The coercion maps from newtype to the representation type
-                       -- (mentioning type variables bound by the forall'd iSpec variables)
-                       -- E.g.   newtype instance N [a] = N1 (Tree a)
-                       --        co : N [a] ~ Tree a
-
-       TyCon           -- The TyCon is the newtype N.  If it's indexed, then it's the 
-                       -- representation TyCon, so that tyConDataCons returns [N1], 
-                       -- the "data constructor".
-                       -- See Note [Newtype deriving and unused constructors]
+                        -- witness dictionary is identical to the argument 
+                        -- dictionary.  Hence no bindings, no pragmas.
+
+        Coercion        -- The coercion maps from newtype to the representation type
+                        -- (mentioning type variables bound by the forall'd iSpec variables)
+                        -- E.g.   newtype instance N [a] = N1 (Tree a)
+                        --        co : N [a] ~ Tree a
+
+        TyCon           -- The TyCon is the newtype N.  If it's indexed, then it's the 
+                        -- representation TyCon, so that tyConDataCons returns [N1], 
+                        -- the "data constructor".
+                        -- See Note [Newtype deriving and unused constructors]
                         -- in TcDeriv
 
 pprInstInfo :: InstInfo a -> SDoc
@@ -630,7 +630,7 @@ simpleInstInfoTy info = snd (simpleInstInfoClsTy info)
 
 simpleInstInfoTyCon :: InstInfo a -> TyCon
   -- Gets the type constructor for a simple instance declaration,
-  -- i.e. one of the form      instance (...) => C (T a b c) where ...
+  -- i.e. one of the form       instance (...) => C (T a b c) where ...
 simpleInstInfoTyCon inst = tcTyConAppTyCon (simpleInstInfoTy inst)
 \end{code}
 
@@ -640,12 +640,12 @@ name, like otber top-level names, and hence must be made with newGlobalBinder.
 \begin{code}
 newDFunName :: Class -> [Type] -> SrcSpan -> TcM Name
 newDFunName clas tys loc
-  = do { is_boot <- tcIsHsBoot
-       ; mod     <- getModule
-       ; let info_string = occNameString (getOccName clas) ++ 
-                           concatMap (occNameString.getDFunTyKey) tys
+  = do  { is_boot <- tcIsHsBoot
+        ; mod     <- getModule
+        ; let info_string = occNameString (getOccName clas) ++ 
+                            concatMap (occNameString.getDFunTyKey) tys
         ; dfun_occ <- chooseUniqueOccTc (mkDFunOcc info_string is_boot)
-       ; newGlobalBinder mod dfun_occ loc }
+        ; newGlobalBinder mod dfun_occ loc }
 \end{code}
 
 Make a name for the representation tycon of a family instance.  It's an
@@ -655,11 +655,11 @@ newGlobalBinder.
 \begin{code}
 newFamInstTyConName :: Located Name -> [Type] -> TcM Name
 newFamInstTyConName (L loc tc_name) tys
-  = do { mod   <- getModule
-       ; let info_string = occNameString (getOccName tc_name) ++ 
-                           concatMap (occNameString.getDFunTyKey) tys
+  = do  { mod   <- getModule
+        ; let info_string = occNameString (getOccName tc_name) ++ 
+                            concatMap (occNameString.getDFunTyKey) tys
         ; occ   <- chooseUniqueOccTc (mkInstTyTcOcc info_string)
-       ; newGlobalBinder mod occ loc }
+        ; newGlobalBinder mod occ loc }
 \end{code}
 
 Stable names used for foreign exports and annotations.
@@ -677,7 +677,7 @@ mkStableIdFromString str sig_ty loc occ_wrapper = do
     let uniq_str = showSDoc (pprUnique uniq) :: String
         occ = mkVarOcc (str ++ '_' : uniq_str) :: OccName
         gnm = mkExternalName uniq mod (occ_wrapper occ) loc :: Name
-       id  = mkExportedLocalId gnm sig_ty :: Id
+        id  = mkExportedLocalId gnm sig_ty :: Id
     return id
 
 mkStableIdFromName :: Name -> Type -> SrcSpan -> (OccName -> OccName) -> TcM TcId
@@ -685,9 +685,9 @@ mkStableIdFromName nm = mkStableIdFromString (getOccString nm)
 \end{code}
 
 %************************************************************************
-%*                                                                     *
+%*                                                                      *
 \subsection{Errors}
-%*                                                                     *
+%*                                                                      *
 %************************************************************************
 
 \begin{code}
@@ -709,5 +709,5 @@ notFound name
 wrongThingErr :: String -> TcTyThing -> Name -> TcM a
 wrongThingErr expected thing name
   = failWithTc (pprTcTyThingCategory thing <+> quotes (ppr name) <+> 
-               ptext (sLit "used as a") <+> text expected)
+                ptext (sLit "used as a") <+> text expected)
 \end{code}