fix spelling: "infered" -> "inferred"

compiler/main/DynFlags.hs

@@ -373,15 +373,15 @@ data SafeHaskellMode
    | Sf_Unsafe
    | Sf_Trustworthy
    | Sf_Safe
-   | Sf_SafeInfered
+   | Sf_SafeInferred
    deriving (Eq)
 
 instance Outputable SafeHaskellMode where
-    ppr Sf_None        = ptext $ sLit "None"
-    ppr Sf_Unsafe      = ptext $ sLit "Unsafe"
-    ppr Sf_Trustworthy = ptext $ sLit "Trustworthy"
-    ppr Sf_Safe        = ptext $ sLit "Safe"
-    ppr Sf_SafeInfered = ptext $ sLit "Safe-Infered"
+    ppr Sf_None         = ptext $ sLit "None"
+    ppr Sf_Unsafe       = ptext $ sLit "Unsafe"
+    ppr Sf_Trustworthy  = ptext $ sLit "Trustworthy"
+    ppr Sf_Safe         = ptext $ sLit "Safe"
+    ppr Sf_SafeInferred = ptext $ sLit "Safe-Inferred"
 
 data ExtensionFlag
    = Opt_Cpp
@@ -950,7 +950,7 @@ defaultDynFlags mySettings =
         warningFlags = IntSet.fromList (map fromEnum standardWarnings),
         ghciScripts = [],
         language = Nothing,
-        safeHaskell = Sf_SafeInfered,
+        safeHaskell = Sf_SafeInferred,
         thOnLoc = noSrcSpan,
         newDerivOnLoc = noSrcSpan,
         pkgTrustOnLoc = noSrcSpan,
@@ -1138,7 +1138,7 @@ safeLanguageOn dflags = safeHaskell dflags == Sf_Safe
 
 -- | Is the Safe Haskell safe inference mode active
 safeInferOn :: DynFlags -> Bool
-safeInferOn dflags = safeHaskell dflags == Sf_SafeInfered
+safeInferOn dflags = safeHaskell dflags == Sf_SafeInferred
 
 -- | Test if Safe Imports are on in some form
 safeImportsOn :: DynFlags -> Bool
@@ -1169,12 +1169,12 @@ safeImplicitImpsReq d = safeLanguageOn d
 -- want to export this functionality from the module but do want to export the
 -- type constructors.
 combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
-combineSafeFlags a b | a == Sf_SafeInfered = return b
-                     | b == Sf_SafeInfered = return a
-                     | a == Sf_None        = return b
-                     | b == Sf_None        = return a
-                     | a == b              = return a
-                     | otherwise           = addErr errm >> return (panic errm)
+combineSafeFlags a b | a == Sf_SafeInferred = return b
+                     | b == Sf_SafeInferred = return a
+                     | a == Sf_None         = return b
+                     | b == Sf_None         = return a
+                     | a == b               = return a
+                     | otherwise            = addErr errm >> return (panic errm)
     where errm = "Incompatible Safe Haskell flags! ("
                     ++ showPpr a ++ ", " ++ showPpr b ++ ")"
 
@@ -1424,7 +1424,7 @@ safeFlagCheck cmdl dflags =
 
               | otherwise
               -> (dflags' { safeHaskell = Sf_None }, [])
-                -- Have we infered Unsafe?
+                -- Have we inferred Unsafe?
                 -- See Note [HscMain . Safe Haskell Inference]
     where
         -- TODO: Can we do better than this for inference?

compiler/main/HscMain.hs

@@ -447,7 +447,7 @@ tcRnModule' hsc_env sum save_rn_syntax mod = do
             return tcg_res'
   where
     pprMod t  = ppr $ moduleName $ tcg_mod t
-    errSafe t = quotes (pprMod t) <+> text "has been infered as safe!"
+    errSafe t = quotes (pprMod t) <+> text "has been inferred as safe!"
 
 -- | Convert a typechecked module to Core
 hscDesugar :: HscEnv -> ModSummary -> TcGblEnv -> IO ModGuts
@@ -927,7 +927,7 @@ hscCheckSafeImports tcg_env = do
               safeHaskell dflags == Sf_None
             -> wipeTrust tcg_env' $ warns (tcg_rules tcg_env')
 
-              -- trustworthy OR safe infered with no RULES
+              -- trustworthy OR safe inferred with no RULES
             | otherwise
             -> return tcg_env'
 
@@ -1049,7 +1049,7 @@ hscCheckSafe' dflags m l = do
                 let trust = getSafeMode $ mi_trust iface'
                     trust_own_pkg = mi_trust_pkg iface'
                     -- check module is trusted
-                    safeM = trust `elem` [Sf_SafeInfered, Sf_Safe, Sf_Trustworthy]
+                    safeM = trust `elem` [Sf_SafeInferred, Sf_Safe, Sf_Trustworthy]
                     -- check package is trusted
                     safeP = packageTrusted trust trust_own_pkg m
                     -- pkg trust reqs
@@ -1079,9 +1079,9 @@ hscCheckSafe' dflags m l = do
     -- otherwise we check the package trust flag.
     packageTrusted :: SafeHaskellMode -> Bool -> Module -> Bool
     packageTrusted _ _ _
-        | not (packageTrustOn dflags)     = True
-    packageTrusted Sf_Safe        False _ = True
-    packageTrusted Sf_SafeInfered False _ = True
+        | not (packageTrustOn dflags)      = True
+    packageTrusted Sf_Safe         False _ = True
+    packageTrusted Sf_SafeInferred False _ = True
     packageTrusted _ _ m
         | isHomePkg m = True
         | otherwise   = trusted $ getPackageDetails (pkgState dflags)
@@ -1130,7 +1130,7 @@ checkPkgTrust dflags pkgs =
 
 -- | Set module to unsafe and wipe trust information.
 --
--- Make sure to call this method to set a module to infered unsafe,
+-- Make sure to call this method to set a module to inferred unsafe,
 -- it should be a central and single failure method.
 wipeTrust :: TcGblEnv -> WarningMessages -> Hsc TcGblEnv
 wipeTrust tcg_env whyUnsafe = do
@@ -1146,7 +1146,7 @@ wipeTrust tcg_env whyUnsafe = do
   where
     wiped_trust   = (tcg_imports tcg_env) { imp_trust_pkgs = [] }
     pprMod        = ppr $ moduleName $ tcg_mod tcg_env
-    whyUnsafe' df = vcat [ quotes pprMod <+> text "has been infered as unsafe!"
+    whyUnsafe' df = vcat [ quotes pprMod <+> text "has been inferred as unsafe!"
                          , text "Reason:"
                          , nest 4 $ (vcat $ badFlags df) $+$
                                     (vcat $ pprErrMsgBagWithLoc whyUnsafe)

compiler/main/HscTypes.lhs

@@ -2059,26 +2059,26 @@ noIfaceTrustInfo = setSafeMode Sf_None
 trustInfoToNum :: IfaceTrustInfo -> Word8
 trustInfoToNum it
   = case getSafeMode it of
-            Sf_None        -> 0
-            Sf_Unsafe      -> 1
-            Sf_Trustworthy -> 2
-            Sf_Safe        -> 3
-            Sf_SafeInfered -> 4
+            Sf_None         -> 0
+            Sf_Unsafe       -> 1
+            Sf_Trustworthy  -> 2
+            Sf_Safe         -> 3
+            Sf_SafeInferred -> 4
 
 numToTrustInfo :: Word8 -> IfaceTrustInfo
 numToTrustInfo 0 = setSafeMode Sf_None
 numToTrustInfo 1 = setSafeMode Sf_Unsafe
 numToTrustInfo 2 = setSafeMode Sf_Trustworthy
 numToTrustInfo 3 = setSafeMode Sf_Safe
-numToTrustInfo 4 = setSafeMode Sf_SafeInfered
+numToTrustInfo 4 = setSafeMode Sf_SafeInferred
 numToTrustInfo n = error $ "numToTrustInfo: bad input number! (" ++ show n ++ ")"
 
 instance Outputable IfaceTrustInfo where
-    ppr (TrustInfo Sf_None)         = ptext $ sLit "none"
-    ppr (TrustInfo Sf_Unsafe)       = ptext $ sLit "unsafe"
-    ppr (TrustInfo Sf_Trustworthy)  = ptext $ sLit "trustworthy"
-    ppr (TrustInfo Sf_Safe)         = ptext $ sLit "safe"
-    ppr (TrustInfo Sf_SafeInfered)  = ptext $ sLit "safe-infered"
+    ppr (TrustInfo Sf_None)          = ptext $ sLit "none"
+    ppr (TrustInfo Sf_Unsafe)        = ptext $ sLit "unsafe"
+    ppr (TrustInfo Sf_Trustworthy)   = ptext $ sLit "trustworthy"
+    ppr (TrustInfo Sf_Safe)          = ptext $ sLit "safe"
+    ppr (TrustInfo Sf_SafeInferred)  = ptext $ sLit "safe-inferred"
 \end{code}
 
 %************************************************************************

compiler/typecheck/TcRnTypes.lhs

@@ -323,8 +323,9 @@ data TcGblEnv
         tcg_main      :: Maybe Name,         -- ^ The Name of the main
                                              -- function, if this module is
                                              -- the main module.
-        tcg_safeInfer :: TcRef Bool          -- Has the typechecker infered this
-                                             -- module as -XSafe (Safe Haskell)
+        tcg_safeInfer :: TcRef Bool          -- Has the typechecker
+                                             -- inferred this module
+                                             -- as -XSafe (Safe Haskell)
     }
 
 data RecFieldEnv 

ghc/InteractiveUI.hs

@@ -1472,7 +1472,7 @@ isSafeModule m = do
         False -> liftIO $ putStrLn $ mname ++ " is NOT trusted!"
 
   where
-    goodTrust t = t `elem` [Sf_Safe, Sf_SafeInfered, Sf_Trustworthy]
+    goodTrust t = t `elem` [Sf_Safe, Sf_SafeInferred, Sf_Trustworthy]
 
     mname = GHC.moduleNameString $ GHC.moduleName m