Typos in comments [ci skip]
authorGabor Greif <ggreif@gmail.com>
Thu, 4 May 2017 16:33:57 +0000 (18:33 +0200)
committerGabor Greif <ggreif@gmail.com>
Fri, 5 May 2017 10:26:26 +0000 (12:26 +0200)
compiler/basicTypes/OccName.hs
compiler/llvmGen/LlvmCodeGen/Ppr.hs
compiler/simplCore/FloatIn.hs
compiler/stranal/DmdAnal.hs
rts/RetainerSet.h
rts/posix/itimer/Pthread.c
testsuite/config/ghc
testsuite/tests/indexed-types/should_compile/T3787.hs
testsuite/tests/simplCore/should_compile/T8848.hs

index f9c875e..0fa2749 100644 (file)
@@ -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
index 8b6340d..16c5518 100644 (file)
@@ -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.
index 34b0b42..e765455 100644 (file)
@@ -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.
 
index 78eefe3..4991241 100644 (file)
@@ -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.
index 60b7c2e..52f12dc 100644 (file)
@@ -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
index a4f5552..e15ac25 100644 (file)
@@ -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:
  *
index 6a368e8..6296394 100644 (file)
@@ -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.
 #
index 9c679f8..06063ff 100644 (file)
@@ -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.
index dff86d4..32797ad 100644 (file)
@@ -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)