diff options
| -rw-r--r-- | compiler/basicTypes/OccName.hs | 2 | ||||
| -rw-r--r-- | compiler/llvmGen/LlvmCodeGen/Ppr.hs | 4 | ||||
| -rw-r--r-- | compiler/simplCore/FloatIn.hs | 2 | ||||
| -rw-r--r-- | compiler/stranal/DmdAnal.hs | 16 | ||||
| -rw-r--r-- | rts/RetainerSet.h | 2 | ||||
| -rw-r--r-- | rts/posix/itimer/Pthread.c | 2 | ||||
| -rw-r--r-- | testsuite/config/ghc | 2 | ||||
| -rw-r--r-- | testsuite/tests/indexed-types/should_compile/T3787.hs | 2 | ||||
| -rw-r--r-- | testsuite/tests/simplCore/should_compile/T8848.hs | 4 |
9 files changed, 18 insertions, 18 deletions
diff --git a/compiler/basicTypes/OccName.hs b/compiler/basicTypes/OccName.hs index f9c875e2f6..0fa2749ba1 100644 --- a/compiler/basicTypes/OccName.hs +++ b/compiler/basicTypes/OccName.hs @@ -854,7 +854,7 @@ would like to see is To achieve this, the function avoidClashesOccEnv can be used to prepare the TidyEnv, by “blocking” every name that occurs twice in the map. This way, none -of the "a"s will get the priviledge of keeping this name, and all of them will +of the "a"s will get the privilege of keeping this name, and all of them will get a suitable number by tidyOccName. This prepared TidyEnv can then be used with tidyOccName. See tidyTyCoVarBndrs diff --git a/compiler/llvmGen/LlvmCodeGen/Ppr.hs b/compiler/llvmGen/LlvmCodeGen/Ppr.hs index 8b6340d6f8..16c55188b4 100644 --- a/compiler/llvmGen/LlvmCodeGen/Ppr.hs +++ b/compiler/llvmGen/LlvmCodeGen/Ppr.hs @@ -175,10 +175,10 @@ pprLlvmCmmDecl (CmmProc mb_info entry_lbl live (ListGraph blks)) -- '------------' -- -- Why this @<name> and @<name>$def? As the textual llvm ir - -- generator is only handed typeless labes, it often does not + -- generator is only handed typeless labels, it often does not -- know the type of the label (e.g. function to call), until -- the actual call happens. However, llvm requires symbol - -- lookups to be typed. Therfore we create the actual function + -- lookups to be typed. Therefore we create the actual function -- as @<name>$def, and alias a bitcast to i8* as @<name>. -- Any subsequent lookup can lookup @<name> as i8* and -- bitcast it to the required type once we want to call it. diff --git a/compiler/simplCore/FloatIn.hs b/compiler/simplCore/FloatIn.hs index 34b0b42365..e765455dfc 100644 --- a/compiler/simplCore/FloatIn.hs +++ b/compiler/simplCore/FloatIn.hs @@ -409,7 +409,7 @@ But there are wrinkles Solution: only float cases into the branches of other cases, and not into the arguments of an application, or the RHS of a let. This - is somewhat conservative, but it's simple. And it stil hits the + is somewhat conservative, but it's simple. And it still hits the cases like Trac #5658. This is implemented in sepBindsByJoinPoint; if is_case is False we dump all floating cases right here. diff --git a/compiler/stranal/DmdAnal.hs b/compiler/stranal/DmdAnal.hs index 78eefe39a1..49912413e4 100644 --- a/compiler/stranal/DmdAnal.hs +++ b/compiler/stranal/DmdAnal.hs @@ -312,7 +312,7 @@ dmdAnal' env dmd (Let (NonRec id rhs) body) env1 = extendAnalEnv NotTopLevel env id1 (idStrictness id1) (body_ty, body') = dmdAnal env1 dmd body (body_ty1, id2) = annotateBndr env body_ty id1 - body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleasheable free variables] + body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleashable free variables] -- If the actual demand is better than the vanilla call -- demand, you might think that we might do better to re-analyse @@ -332,7 +332,7 @@ dmdAnal' env dmd (Let (Rec pairs) body) (env', lazy_fv, pairs') = dmdFix NotTopLevel env dmd pairs (body_ty, body') = dmdAnal env' dmd body body_ty1 = deleteFVs body_ty (map fst pairs) - body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleasheable free variables] + body_ty2 = addLazyFVs body_ty1 lazy_fv -- see Note [Lazy and unleashable free variables] in body_ty2 `seq` (body_ty2, Let (Rec pairs') body') @@ -527,7 +527,7 @@ dmdFix top_lvl env let_dmd orig_pairs abort :: (AnalEnv, DmdEnv, [(Id,CoreExpr)]) abort = (env, lazy_fv', zapped_pairs) where (lazy_fv, pairs') = step True (zapIdStrictness orig_pairs) - -- Note [Lazy and unleasheable free variables] + -- Note [Lazy and unleashable free variables] non_lazy_fvs = plusVarEnvList $ map (strictSigDmdEnv . idStrictness . fst) pairs' lazy_fv' = lazy_fv `plusVarEnv` mapVarEnv (const topDmd) non_lazy_fvs zapped_pairs = zapIdStrictness pairs' @@ -579,7 +579,7 @@ return the environment and code unchanged! We still need to do one additional round, for two reasons: * To get information on used free variables (both lazy and strict!) - (see Note [Lazy and unleasheable free variables]) + (see Note [Lazy and unleashable free variables]) * To ensure that all expressions have been traversed at least once, and any left-over strictness annotations have been updated. @@ -721,14 +721,14 @@ evalDmd, and think that it was lazy in p. But for join points we can do better! We know that j's body will (if called at all) be evaluated with the demand that consumes the entire join-binding, in this case the argument demand from g. Whizzo! g evaluates both components of -its arugment pair, so p will certainly be evaluated if j is called. +its argument pair, so p will certainly be evaluated if j is called. For f to be strict in p, we need /all/ paths to evaluate p; in this case the C branch does so too, so we are fine. So, as usual, we need to transport demands on free variables to the call site(s). Compare -Note [Lazy and unleasheable free variables]. +Note [Lazy and unleashable free variables]. -The implementation is easy. Wwhen analysing a join point, we can +The implementation is easy. When analysing a join point, we can analyse its body with the demand from the entire join-binding (written let_dmd here). @@ -1032,7 +1032,7 @@ strictness. For example, if you have a function implemented by an error stub, but which has RULES, you may want it not to be eliminated in favour of error! -Note [Lazy and unleasheable free variables] +Note [Lazy and unleashable free variables] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We put the strict and once-used FVs in the DmdType of the Id, so that at its call sites we unleash demands on its strict fvs. diff --git a/rts/RetainerSet.h b/rts/RetainerSet.h index 60b7c2e1d2..52f12dc155 100644 --- a/rts/RetainerSet.h +++ b/rts/RetainerSet.h @@ -106,7 +106,7 @@ RetainerSet *singleton(retainer r); extern RetainerSet rs_MANY; -// Checks if a given retainer is a memeber of the retainer set. +// Checks if a given retainer is a member of the retainer set. // // Note & (maybe) Todo: // This function needs to be declared as an inline function, so it is declared diff --git a/rts/posix/itimer/Pthread.c b/rts/posix/itimer/Pthread.c index a4f55527dd..e15ac2521e 100644 --- a/rts/posix/itimer/Pthread.c +++ b/rts/posix/itimer/Pthread.c @@ -22,7 +22,7 @@ * * In the threaded RTS, we can't tick in CPU time because the thread * which has the virtual timer might be idle, so the tick would never - * fire. Therfore we used to tick in realtime in the threaded RTS and + * fire. Therefore we used to tick in realtime in the threaded RTS and * in CPU time otherwise, but now we always tick in realtime, for * several reasons: * diff --git a/testsuite/config/ghc b/testsuite/config/ghc index 6a368e8634..6296394197 100644 --- a/testsuite/config/ghc +++ b/testsuite/config/ghc @@ -229,7 +229,7 @@ def get_compiler_info(): # Arguably the above code for writing `:set args` should be smarter. This # is tricky to get right though, because in GHCI `:set args foo\bar` (no # double quotes) works perfectly fine, and is interpreted as the Haskell -# string "foo\\bar". Therfore, simply escaping all backward slashes in +# string "foo\\bar". Therefore, simply escaping all backward slashes in # opts.extra_run_opts before concatenating it with ':set args' is not right # either. # diff --git a/testsuite/tests/indexed-types/should_compile/T3787.hs b/testsuite/tests/indexed-types/should_compile/T3787.hs index 9c679f840e..06063ff113 100644 --- a/testsuite/tests/indexed-types/should_compile/T3787.hs +++ b/testsuite/tests/indexed-types/should_compile/T3787.hs @@ -364,7 +364,7 @@ data Sink (m :: * -> *) a x = { -- | Function 'put' tries to put a value into the given `Sink`. The intervening 'Trampoline' computations suspend up -- to the 'pipe' invocation that has created the argument sink. The result of 'put' indicates whether the operation - -- succeded. + -- succeeded. put :: forall d. (AncestorFunctor a d) => x -> Trampoline d m Bool, -- | Function 'canPut' checks if the argument `Sink` accepts values, i.e., whether a 'put' operation would succeed on -- the sink. diff --git a/testsuite/tests/simplCore/should_compile/T8848.hs b/testsuite/tests/simplCore/should_compile/T8848.hs index dff86d4541..32797adea2 100644 --- a/testsuite/tests/simplCore/should_compile/T8848.hs +++ b/testsuite/tests/simplCore/should_compile/T8848.hs @@ -19,8 +19,8 @@ instance Fun.Functor (Shape Z) where instance (Fun.Functor (Shape r)) => Fun.Functor (Shape (S r)) where map2 :: (A.Applicative (Shape r))=> (a->b ->c) -> (Shape r a) -> (Shape r b) -> [Shape r c] --- Artifically made recursive so that it won't inline, --- se we can see if the speicalisation happens +-- Artificially made recursive so that it won't inline, +-- so we can see if the specialisation happens map2 = \f l r -> (A.pure f A.<*> l A.<*> r) : map2 f l r {-# SPECIALIZE map2 :: (a->b->c) |