Fix typoswip/typos2

64 files changed, 86 insertions, 84 deletions

diff --git a/compiler/GHC/Builtin/primops.txt.pp b/compiler/GHC/Builtin/primops.txt.pp
index acd84c0926..3a76c33819 100644
--- a/compiler/GHC/Builtin/primops.txt.pp
+++ b/compiler/GHC/Builtin/primops.txt.pp
@@ -3658,7 +3658,7 @@ section "Etc"
 ------------------------------------------------------------------------
 
 primtype FUN m a b
-  {The builtin function type, written in infix form as @a # m -> b@.
+  {The builtin function type, written in infix form as @a % m -> b@.
    Values of this type are functions taking inputs of type @a@ and
    producing outputs of type @b@. The multiplicity of the input is
    @m@.
diff --git a/compiler/GHC/Cmm/Reg.hs b/compiler/GHC/Cmm/Reg.hs
index a37e5ce6f8..6c94ecb2eb 100644
--- a/compiler/GHC/Cmm/Reg.hs
+++ b/compiler/GHC/Cmm/Reg.hs
@@ -352,7 +352,7 @@ globalRegType platform = \case
    (LongReg _)              -> cmmBits W64
    -- TODO: improve the internal model of SIMD/vectorized registers
    -- the right design SHOULd improve handling of float and double code too.
-   -- see remarks in "NOTE [SIMD Design for the future]"" in GHC.StgToCmm.Prim
+   -- see remarks in Note [SIMD Design for the future] in GHC.StgToCmm.Prim
    (XmmReg _) -> cmmVec 4 (cmmBits W32)
    (YmmReg _) -> cmmVec 8 (cmmBits W32)
    (ZmmReg _) -> cmmVec 16 (cmmBits W32)
diff --git a/compiler/GHC/CmmToAsm/AArch64/Ppr.hs b/compiler/GHC/CmmToAsm/AArch64/Ppr.hs
index a27a3297e3..a42a3043db 100644
--- a/compiler/GHC/CmmToAsm/AArch64/Ppr.hs
+++ b/compiler/GHC/CmmToAsm/AArch64/Ppr.hs
@@ -273,7 +273,7 @@ pprIm platform im = case im of
   -- This is something the x86 backend does.
   --
   -- We could also just turn them into statics :-/ Which is what the
-  -- PowerPC backend odes.
+  -- PowerPC backend does.
   ImmFloat f | f == 0 -> text "wzr"
   ImmFloat f -> char '#' <> float (fromRational f)
   ImmDouble d | d == 0 -> text "xzr"
diff --git a/compiler/GHC/CmmToAsm/CFG.hs b/compiler/GHC/CmmToAsm/CFG.hs
index 71a1ce6a62..7da070d1b5 100644
--- a/compiler/GHC/CmmToAsm/CFG.hs
+++ b/compiler/GHC/CmmToAsm/CFG.hs
@@ -307,7 +307,7 @@ shortcutWeightMap cuts cfg
         -- Create a unification variable for each of the nodes in a rewrite
         cuts_vars <- traverse (\p -> (p,) <$> fresh (Just p)) (concatMap (\(a, b) -> [a] ++ maybe [] (:[]) b) cuts_list)
         let cuts_map = mapFromList cuts_vars :: LabelMap (Point s (Maybe BlockId))
-        -- Then unify according the the rewrites in the cuts map
+        -- Then unify according to the rewrites in the cuts map
         mapM_ (\(from, to) -> expectJust "shortcutWeightMap" (mapLookup from cuts_map)
                               `union` expectJust "shortcutWeightMap" (maybe (Just null) (flip mapLookup cuts_map) to) ) cuts_list
         -- Then recover the unique representative, which is the result of following
diff --git a/compiler/GHC/Core/Coercion.hs b/compiler/GHC/Core/Coercion.hs
index 15ee9369da..917022c78d 100644
--- a/compiler/GHC/Core/Coercion.hs
+++ b/compiler/GHC/Core/Coercion.hs
@@ -874,7 +874,7 @@ Sadly, with heterogeneous equality, this restriction might be able to be violate
 Richard's thesis is unable to prove that it isn't. Specifically, the liftCoSubst
 function might create an invalid coercion. Because a violation of the
 restriction might lead to a program that "goes wrong", it is checked all the time,
-even in a production compiler and without -dcore-list. We *have* proved that the
+even in a production compiler and without -dcore-lint. We *have* proved that the
 problem does not occur with homogeneous equality, so this check can be dropped
 once ~# is made to be homogeneous.
 -}
diff --git a/compiler/GHC/Core/Lint.hs b/compiler/GHC/Core/Lint.hs
index ce0e83669f..a9d01787fd 100644
--- a/compiler/GHC/Core/Lint.hs
+++ b/compiler/GHC/Core/Lint.hs
@@ -732,7 +732,7 @@ Now $cnoteq is not a loop breaker any more, so the INLINE pragma can
 take effect -- the warning turned out to be temporary.
 
 To stop excessive warnings, this warning for INLINE loop breakers is
-switched off when linting the the result of the desugarer.  See
+switched off when linting the result of the desugarer.  See
 lf_check_inline_loop_breakers in GHC.Core.Lint.
 
 
diff --git a/compiler/GHC/Core/Make.hs b/compiler/GHC/Core/Make.hs
index 8039924051..41757c0d30 100644
--- a/compiler/GHC/Core/Make.hs
+++ b/compiler/GHC/Core/Make.hs
@@ -263,7 +263,7 @@ mkUncheckedIntExpr i = mkCoreConApps intDataCon  [Lit (mkLitIntUnchecked i)]
 mkIntExprInt :: Platform -> Int -> CoreExpr         -- Result = I# i :: Int
 mkIntExprInt platform i = mkCoreConApps intDataCon  [mkIntLit platform (fromIntegral i)]
 
--- | Create a 'CoreExpr' which will evaluate to the a @Word@ with the given value
+-- | Create a 'CoreExpr' which will evaluate to a @Word@ with the given value
 mkWordExpr :: Platform -> Integer -> CoreExpr
 mkWordExpr platform w = mkCoreConApps wordDataCon [mkWordLit platform w]
 
diff --git a/compiler/GHC/Core/Opt/DmdAnal.hs b/compiler/GHC/Core/Opt/DmdAnal.hs
index 011f02af5f..fe98075487 100644
--- a/compiler/GHC/Core/Opt/DmdAnal.hs
+++ b/compiler/GHC/Core/Opt/DmdAnal.hs
@@ -1376,7 +1376,7 @@ Here is another important case (B):
 
 Again we want `wombat` to pretend to take its Int-typed argument unboxed,
 even though it has to pass it boxed to `f`, so that `g` can take its
-arugment unboxed (and rebox it before calling `wombat`).
+argument unboxed (and rebox it before calling `wombat`).
 
 So here's what we do: while summarising `indexError`'s boxity signature in
 `finaliseArgBoxities`:
diff --git a/compiler/GHC/Core/Opt/LiberateCase.hs b/compiler/GHC/Core/Opt/LiberateCase.hs
index 863a19d961..0249b23aaf 100644
--- a/compiler/GHC/Core/Opt/LiberateCase.hs
+++ b/compiler/GHC/Core/Opt/LiberateCase.hs
@@ -173,7 +173,7 @@ libCaseBind env (Rec pairs)
 {- Note [Not bottoming Ids]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Do not specialise error-functions (this is unusual, but I once saw it,
-(actually in Data.Typable.Internal)
+(actually in Data.Typeable.Internal)
 
 Note [Only functions!]
 ~~~~~~~~~~~~~~~~~~~~~~
diff --git a/compiler/GHC/Core/Opt/Monad.hs b/compiler/GHC/Core/Opt/Monad.hs
index 2d3d9822a2..a195f3997e 100644
--- a/compiler/GHC/Core/Opt/Monad.hs
+++ b/compiler/GHC/Core/Opt/Monad.hs
@@ -267,7 +267,7 @@ getUniqMask = read cr_uniq_mask
 
 -- Convenience accessors for useful fields of HscEnv
 
--- | Adjust the dyn flags passed to the arugment action
+-- | Adjust the dyn flags passed to the argument action
 mapDynFlagsCoreM :: (DynFlags -> DynFlags) -> CoreM a -> CoreM a
 mapDynFlagsCoreM f m = CoreM $ do
   !e <- getEnv
diff --git a/compiler/GHC/Core/Opt/OccurAnal.hs b/compiler/GHC/Core/Opt/OccurAnal.hs
index 4a67b8cdea..59158a0e90 100644
--- a/compiler/GHC/Core/Opt/OccurAnal.hs
+++ b/compiler/GHC/Core/Opt/OccurAnal.hs
@@ -1867,7 +1867,7 @@ occAnalLam env expr = occAnal env expr
 {- Note [Occ-anal and cast worker/wrapper]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider   y = e; x = y |> co
-If we mark y as used-once, we'll inline y into x, and the the Cast
+If we mark y as used-once, we'll inline y into x, and the Cast
 worker/wrapper transform will float it straight back out again.  See
 Note [Cast worker/wrapper] in GHC.Core.Opt.Simplify.
 
diff --git a/compiler/GHC/Core/Opt/Simplify/Iteration.hs b/compiler/GHC/Core/Opt/Simplify/Iteration.hs
index 9fea132486..cfee2e5e56 100644
--- a/compiler/GHC/Core/Opt/Simplify/Iteration.hs
+++ b/compiler/GHC/Core/Opt/Simplify/Iteration.hs
@@ -2939,7 +2939,7 @@ doCaseToLet scrut case_bndr
     -- We can call isUnliftedType here: scrutinees always have a fixed RuntimeRep (see FRRCase).
     -- Note however that we must check 'scrut' (which is an 'OutExpr') and not 'case_bndr'
     -- (which is an 'InId'): see Note [Dark corner with representation polymorphism].
-    -- Using `exprType` is typically cheap becuase `scrut` is typically a variable.
+    -- Using `exprType` is typically cheap because `scrut` is typically a variable.
     -- We could instead use mightBeUnliftedType (idType case_bndr), but that hurts
     -- the brain more.  Consider that if this test ever turns out to be a perf
     -- problem (which seems unlikely).
diff --git a/compiler/GHC/Core/Opt/SpecConstr.hs b/compiler/GHC/Core/Opt/SpecConstr.hs
index 538b457ffc..05c7b00116 100644
--- a/compiler/GHC/Core/Opt/SpecConstr.hs
+++ b/compiler/GHC/Core/Opt/SpecConstr.hs
@@ -1280,7 +1280,7 @@ instance Outputable ArgOcc where
 evalScrutOcc :: ArgOcc
 -- We use evalScrutOcc for
 --   - mkVarUsage: applied functions
---   - scApp: dicts that are the arugment of a classop
+--   - scApp: dicts that are the argument of a classop
 evalScrutOcc = ScrutOcc emptyUFM
 
 -- Experimentally, this version of combineOcc makes ScrutOcc "win", so
@@ -1904,7 +1904,7 @@ spec_one env fn arg_bndrs body (call_pat, rule_number)
               add_void_arg = needsVoidWorkerArg fn arg_bndrs spec_lam_args1
               (spec_lam_args, spec_call_args, spec_arity, spec_join_arity)
                   | add_void_arg
-                  -- See Note [SpecConst needs to add void args first]
+                  -- See Note [SpecConstr needs to add void args first]
                   , (spec_lam_args, spec_call_args, _) <- addVoidWorkerArg spec_lam_args1 []
                       -- needsVoidWorkerArg: usual w/w hack to avoid generating
                       -- a spec_rhs of unlifted type and no args.
@@ -1991,8 +1991,8 @@ mkSeqs seqees res_ty rhs =
         = rhs
 
 
-{- Note [SpecConst needs to add void args first]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+{- Note [SpecConstr needs to add void args first]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider a function
     f start @t = e
 We want to specialize for a partially applied call `f True`.
diff --git a/compiler/GHC/Core/Opt/Specialise.hs b/compiler/GHC/Core/Opt/Specialise.hs
index 1b29a924ef..4578f2681d 100644
--- a/compiler/GHC/Core/Opt/Specialise.hs
+++ b/compiler/GHC/Core/Opt/Specialise.hs
@@ -1832,7 +1832,7 @@ where $fCInt_$cm is the instance method for `m` in `instance C Int`:
    $fCInt_$cm :: forall b. Show b => Int -> b -> String
    $fCInt_$cm b d x y = show @Int $dShowInt x ++ show @b d y
 
-We want to specialise this! How? By doing the the method-selection rewrite in
+We want to specialise this! How? By doing the method-selection rewrite in
 the Specialiser. Hence
 
 1. In the App case of 'specExpr', try to apply the ClassOp/DFun rule on the
diff --git a/compiler/GHC/Core/Opt/WorkWrap/Utils.hs b/compiler/GHC/Core/Opt/WorkWrap/Utils.hs
index 5b653e751f..6f6e1ea1c3 100644
--- a/compiler/GHC/Core/Opt/WorkWrap/Utils.hs
+++ b/compiler/GHC/Core/Opt/WorkWrap/Utils.hs
@@ -389,7 +389,7 @@ needsVoidWorkerArg fn_id wrap_args work_args
 
 -- | Inserts a `Void#` arg before the first argument.
 --
--- Why as the first argument? See Note [SpecConst needs to add void args first]
+-- Why as the first argument? See Note [SpecConstr needs to add void args first]
 -- in SpecConstr.
 addVoidWorkerArg :: [Var] -> [StrictnessMark]
                  -> ([Var],     -- Lambda bound args
diff --git a/compiler/GHC/Core/RoughMap.hs b/compiler/GHC/Core/RoughMap.hs
index 2dc7f6954d..87fd641e64 100644
--- a/compiler/GHC/Core/RoughMap.hs
+++ b/compiler/GHC/Core/RoughMap.hs
@@ -106,7 +106,7 @@ instance when queried for an instance with template, e.g., `[KnownTc Fam,
 KnownTc Int, KnownTc Char]`.
 
 This explains the third clause of the mightMatch specification in Note [Simple Matching Semantics].
-As soon as the the lookup key runs out, the remaining instances might match.
+As soon as the lookup key runs out, the remaining instances might match.
 
 Note [Matching a RoughMap]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/compiler/GHC/Core/SimpleOpt.hs b/compiler/GHC/Core/SimpleOpt.hs
index d40136634d..75a5ed27a0 100644
--- a/compiler/GHC/Core/SimpleOpt.hs
+++ b/compiler/GHC/Core/SimpleOpt.hs
@@ -275,7 +275,7 @@ simple_opt_expr env expr
               (env', mb_prs) = mapAccumL (simple_out_bind NotTopLevel) env $
                                zipEqual "simpleOptExpr" bs es
 
-         -- Note [Getting the map/coerce RULE to work]
+         -- See Note [Getting the map/coerce RULE to work]
       | isDeadBinder b
       , [Alt DEFAULT _ rhs] <- as
       , isCoVarType (varType b)
diff --git a/compiler/GHC/Core/TyCon.hs b/compiler/GHC/Core/TyCon.hs
index c8756d3e48..54672ab80d 100644
--- a/compiler/GHC/Core/TyCon.hs
+++ b/compiler/GHC/Core/TyCon.hs
@@ -989,7 +989,7 @@ data TyCon
         tyConArity   :: Arity,         -- ^ Arity
         tyConNullaryTy :: Type,           -- ^ A pre-allocated @TyConApp tycon []@
 
-          -- NB: the TyConArity of a TcTyCon must match
+          -- NB: the tyConArity of a TcTyCon must match
           -- the number of Required (positional, user-specified)
           -- arguments to the type constructor; see the use
           -- of tyConArity in generaliseTcTyCon
@@ -1012,7 +1012,7 @@ The tcTyConScopedTyVars field records the lexicial-binding connection
 between the original, user-specified Name (i.e. thing in scope) and
 the TcTyVar that the Name is bound to.
 
-Order *does* matter; the tcTyConScopedTyvars list consists of
+Order *does* matter; the tcTyConScopedTyVars list consists of
      specified_tvs ++ required_tvs
 
 where
diff --git a/compiler/GHC/Core/Type.hs b/compiler/GHC/Core/Type.hs
index 49db2cb4ca..e51fe7e88c 100644
--- a/compiler/GHC/Core/Type.hs
+++ b/compiler/GHC/Core/Type.hs
@@ -1431,7 +1431,7 @@ piResultTys ty orig_args@(arg:args)
         pprPanic "piResultTys2" (ppr ty $$ ppr orig_args $$ ppr all_args)
 
 applyTysX :: [TyVar] -> Type -> [Type] -> Type
--- applyTyxX beta-reduces (/\tvs. body_ty) arg_tys
+-- applyTysX beta-reduces (/\tvs. body_ty) arg_tys
 -- Assumes that (/\tvs. body_ty) is closed
 applyTysX tvs body_ty arg_tys
   = assertPpr (tvs `leLength` arg_tys) pp_stuff $
@@ -3079,7 +3079,7 @@ tcTypeKind (FunTy { ft_af = af, ft_res = res })
   , tcIsConstraintKind (tcTypeKind res)
   = constraintKind     -- Eq a => Ord a         :: Constraint
   | otherwise          -- Eq a => a -> a        :: TYPE LiftedRep
-  = liftedTypeKind     -- Eq a => Array# Int    :: Type LiftedRep (not TYPE PtrRep)
+  = liftedTypeKind     -- Eq a => Array# Int    :: TYPE LiftedRep (not TYPE PtrRep)
 
 tcTypeKind (AppTy fun arg)
   = go fun [arg]
diff --git a/compiler/GHC/Driver/Backend.hs b/compiler/GHC/Driver/Backend.hs
index afe8176f78..48958594fd 100644
--- a/compiler/GHC/Driver/Backend.hs
+++ b/compiler/GHC/Driver/Backend.hs
@@ -27,7 +27,7 @@ especially the driver.  Examples include the following:
    this back end, then these are the command-line flags you should add
    to any invocation of the C compiler."
 
-These properties are use elsewhere in GHC, primarily in the driver, to
+These properties are used elsewhere in GHC, primarily in the driver, to
 fine-tune operations according to the capabilities of the chosen back
 end.  You might use a property to make GHC aware of a potential
 limitation of certain back ends, or a special feature available only
diff --git a/compiler/GHC/Driver/Make.hs b/compiler/GHC/Driver/Make.hs
index cb0efac6ad..09e6be023a 100644
--- a/compiler/GHC/Driver/Make.hs
+++ b/compiler/GHC/Driver/Make.hs
@@ -2632,7 +2632,7 @@ X.hs     module X where
            data XT = MkX T
            fx = ...g...
 ```
-If in `--make` we compile R.hs-boot, then A.hs, then X.hs, we'll get a `ModDetails` for `X` that has an AbstractTyCon for `T` in the the argument type of `MkX`.  So:
+If in `--make` we compile R.hs-boot, then A.hs, then X.hs, we'll get a `ModDetails` for `X` that has an AbstractTyCon for `T` in the argument type of `MkX`.  So:
 
 * Either we should delay compiling X until after R has been compiled. (This is what we do)
 * Or we should rehydrate X after compiling R -- because it transitively depends on R.hs-boot.
diff --git a/compiler/GHC/HsToCore/Expr.hs b/compiler/GHC/HsToCore/Expr.hs
index 36e289e695..65a83667a3 100644
--- a/compiler/GHC/HsToCore/Expr.hs
+++ b/compiler/GHC/HsToCore/Expr.hs
@@ -468,12 +468,12 @@ For record construction we do this (assuming T has three arguments)
 \begin{verbatim}
         T { op2 = e }
 ==>
-        let err = /\a -> recConErr a
-        T (recConErr t1 "M.hs/230/op1")
+        let err = /\a -> recConError a
+        T (recConError t1 "M.hs/230/op1")
           e
-          (recConErr t1 "M.hs/230/op3")
+          (recConError t1 "M.hs/230/op3")
 \end{verbatim}
-@recConErr@ then converts its argument string into a proper message
+@recConError@ then converts its argument string into a proper message
 before printing it as
 \begin{verbatim}
         M.hs, line 230: missing field op1 was evaluated
diff --git a/compiler/GHC/HsToCore/Pmc/Solver.hs b/compiler/GHC/HsToCore/Pmc/Solver.hs
index d038f397a5..a1bf167903 100644
--- a/compiler/GHC/HsToCore/Pmc/Solver.hs
+++ b/compiler/GHC/HsToCore/Pmc/Solver.hs
@@ -1837,7 +1837,7 @@ DataCons and PatSynCons:
 
 Note [Instantiating a ConLike]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-`instCon` implements the the \(Inst\) function from Figure 8 of the LYG paper.
+`instCon` implements the \(Inst\) function from Figure 8 of the LYG paper.
 
 Given the following type of ConLike `K`
 
diff --git a/compiler/GHC/HsToCore/Utils.hs b/compiler/GHC/HsToCore/Utils.hs
index c21b6af0b3..05992ce499 100644
--- a/compiler/GHC/HsToCore/Utils.hs
+++ b/compiler/GHC/HsToCore/Utils.hs
@@ -494,7 +494,7 @@ There are a few subtleties in the desugaring of `seq`:
        let chp = case b of { True -> fst x; False -> 0 }
        case chp of _ { I# -> ...chp... }
 
-    But since chp is cheap, and the case is an alluring contet, we'll
+    But since chp is cheap, and the case is an alluring context, we'll
     inline chp into the case scrutinee.  Now there is only one use of chp,
     so we'll inline a second copy.  Alas, we've now ruined the purpose of
     the seq, by re-introducing the space leak:
diff --git a/compiler/GHC/Platform/Ways.hs b/compiler/GHC/Platform/Ways.hs
index 955a9bcea0..e66b8a496d 100644
--- a/compiler/GHC/Platform/Ways.hs
+++ b/compiler/GHC/Platform/Ways.hs
@@ -61,7 +61,7 @@ import Data.List (intersperse)
 
 -- | A way
 --
--- Don't change the constructor order as it us used by `waysTag` to create a
+-- Don't change the constructor order as it is used by `waysTag` to create a
 -- unique tag (e.g. thr_debug_p) which is expected by other tools (e.g. Cabal).
 data Way
   = WayCustom String -- ^ for GHC API clients building custom variants
diff --git a/compiler/GHC/Stg/Unarise.hs b/compiler/GHC/Stg/Unarise.hs
index 30234fe57c..440b184d44 100644
--- a/compiler/GHC/Stg/Unarise.hs
+++ b/compiler/GHC/Stg/Unarise.hs
@@ -310,7 +310,7 @@ type UnariseEnv = VarEnv UnariseVal
 
 data UnariseVal
   = MultiVal [OutStgArg] -- MultiVal to tuple. Can be empty list (void).
-  | UnaryVal OutStgArg   -- See NOTE [Renaming during unarisation].
+  | UnaryVal OutStgArg   -- See Note [Renaming during unarisation].
 
 instance Outputable UnariseVal where
   ppr (MultiVal args) = text "MultiVal" <+> ppr args
@@ -709,7 +709,7 @@ For arguments (StgArg) and binders (Id) we have two kind of unarisation:
     Here after unarise we should still get a function with arity 3. Similarly
     in the call site we shouldn't remove void arguments:
 
-      f (# (# #), (# #) #) voidId rw
+      f (# (# #), (# #) #) void# rw
 
     When unarising <body>, we extend the environment with these binders:
 
diff --git a/compiler/GHC/StgToCmm/Expr.hs b/compiler/GHC/StgToCmm/Expr.hs
index 799b9056f1..fcf91b4509 100644
--- a/compiler/GHC/StgToCmm/Expr.hs
+++ b/compiler/GHC/StgToCmm/Expr.hs
@@ -912,7 +912,7 @@ cgAlts _ _ _ _ = panic "cgAlts"
 -- tag from the info table, and switch on that. The only technically
 -- tricky part is that the default case needs (logical) duplication.
 -- To do this we emit an extra label for it and branch to that from
--- the second switch. This avoids duplicated codegen. See Trac #14373.
+-- the second switch. This avoids duplicated codegen. See #14373.
 -- See Note [Double switching for big families] for the mechanics
 -- involved.
 --
diff --git a/compiler/GHC/StgToCmm/Prim.hs b/compiler/GHC/StgToCmm/Prim.hs
index eb26b4a503..d4c336e802 100644
--- a/compiler/GHC/StgToCmm/Prim.hs
+++ b/compiler/GHC/StgToCmm/Prim.hs
@@ -2240,7 +2240,8 @@ vecElemProjectCast _        WordVec  W64 =  Nothing
 vecElemProjectCast _        _        _   =  Nothing
 
 
--- NOTE [SIMD Design for the future]
+-- Note [SIMD Design for the future]
+-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- Check to make sure that we can generate code for the specified vector type
 -- given the current set of dynamic flags.
 -- Currently these checks are specific to x86 and x86_64 architecture.
diff --git a/compiler/GHC/SysTools/BaseDir.hs b/compiler/GHC/SysTools/BaseDir.hs
index 99aebd9bc8..384169188e 100644
--- a/compiler/GHC/SysTools/BaseDir.hs
+++ b/compiler/GHC/SysTools/BaseDir.hs
@@ -122,7 +122,7 @@ play nice with the system compiler instead.
 -- | Expand occurrences of the @$tooldir@ interpolation in a string
 -- on Windows, leave the string untouched otherwise.
 expandToolDir
-  :: Bool -- ^ whether we are use the ambient mingw toolchain
+  :: Bool -- ^ whether we use the ambient mingw toolchain
   -> Maybe FilePath -- ^ tooldir
   -> String -> String
 #if defined(mingw32_HOST_OS)
@@ -166,7 +166,7 @@ tryFindTopDir Nothing
 -- tooldir can't be located, or returns @Just tooldirpath@.
 -- If the distro toolchain is being used we treat Windows the same as Linux
 findToolDir
-  :: Bool -- ^ whether we are use the ambient mingw toolchain
+  :: Bool -- ^ whether we use the ambient mingw toolchain
   -> FilePath -- ^ topdir
   -> IO (Maybe FilePath)
 #if defined(mingw32_HOST_OS)
diff --git a/compiler/GHC/Tc/Errors.hs b/compiler/GHC/Tc/Errors.hs
index 6d0bf4d117..0eb7706434 100644
--- a/compiler/GHC/Tc/Errors.hs
+++ b/compiler/GHC/Tc/Errors.hs
@@ -1363,7 +1363,7 @@ mkHoleError lcl_name_cache tidy_simples ctxt
              , hole_loc = ct_loc })
   = do { rel_binds
            <- relevant_bindings False lcl_env lcl_name_cache (tyCoVarsOfType hole_ty)
-               -- The 'False' means "don't filter the bindings"; see Trac #8191
+               -- The 'False' means "don't filter the bindings"; see #8191
 
        ; show_hole_constraints <- goptM Opt_ShowHoleConstraints
        ; let relevant_cts
diff --git a/compiler/GHC/Tc/Gen/App.hs b/compiler/GHC/Tc/Gen/App.hs
index 7d64f0d1ef..b420cf8c9e 100644
--- a/compiler/GHC/Tc/Gen/App.hs
+++ b/compiler/GHC/Tc/Gen/App.hs
@@ -230,7 +230,7 @@ tcApp works like this:
    returning the function in the corner and the arguments
 
    splitHsApps can deal with infix as well as prefix application,
-   and returns a Rebuilder to re-assemble the the application after
+   and returns a Rebuilder to re-assemble the application after
    typechecking.
 
    The "list of arguments" is [HsExprArg], described in Note [HsExprArg].
@@ -369,7 +369,7 @@ tcApp rn_expr exp_res_ty
                  -- Even though both app_res_rho and exp_res_ty are rho-types,
                  -- they may have nested polymorphism, so if deep subsumption
                  -- is on we must call tcSubType.
-                 -- Zonk app_res_rho first, becuase QL may have instantiated some
+                 -- Zonk app_res_rho first, because QL may have instantiated some
                  -- delta variables to polytypes, and tcSubType doesn't expect that
                  do { app_res_rho <- zonkQuickLook do_ql app_res_rho
                     ; tcSubTypeDS rn_expr app_res_rho exp_res_ty }
@@ -509,7 +509,7 @@ type Delta = TcTyVarSet   -- Set of instantiation variables,
 
 tcInstFun :: Bool   -- True  <=> Do quick-look
           -> Bool   -- False <=> Instantiate only /inferred/ variables at the end
-                    --           so may return a sigma-typex
+                    --           so may return a sigma-type
                     -- True  <=> Instantiate all type variables at the end:
                     --           return a rho-type
                     -- The /only/ call site that passes in False is the one
diff --git a/compiler/GHC/Tc/Gen/Foreign.hs b/compiler/GHC/Tc/Gen/Foreign.hs
index 57b30c9548..b8899e2431 100644
--- a/compiler/GHC/Tc/Gen/Foreign.hs
+++ b/compiler/GHC/Tc/Gen/Foreign.hs
@@ -198,7 +198,7 @@ used even though it is not mentioned expclitly in the source, so we don't
 want to report it as "defined but not used" or "imported but not used".
 eg     newtype D = MkD Int
        foreign import foo :: D -> IO ()
-Here 'MkD' us used.  See #7408.
+Here 'MkD' is used.  See #7408.
 
 GHC also expands type functions during this process, so it's not enough
 just to look at the free variables of the declaration.
diff --git a/compiler/GHC/Tc/Gen/Sig.hs b/compiler/GHC/Tc/Gen/Sig.hs
index 138e61978c..cfc5454e54 100644
--- a/compiler/GHC/Tc/Gen/Sig.hs
+++ b/compiler/GHC/Tc/Gen/Sig.hs
@@ -455,7 +455,7 @@ tcPatSynSig name sig_ty@(L _ (HsSig{sig_bndrs = hs_outer_bndrs, sig_body = hs_ty
 
        -- Neither argument types nor the return type may be representation polymorphic.
        -- This is because, when creating a matcher:
-       --   - the argument types become the the binder types (see test RepPolyPatySynArg),
+       --   - the argument types become the binder types (see test RepPolyPatySynArg),
        --   - the return type becomes the scrutinee type (see test RepPolyPatSynRes).
        ; let (arg_tys, res_ty) = tcSplitFunTys body_ty
        ; mapM_
diff --git a/compiler/GHC/Tc/Gen/Splice.hs b/compiler/GHC/Tc/Gen/Splice.hs
index 47d19c127b..e7a45a5be9 100644
--- a/compiler/GHC/Tc/Gen/Splice.hs
+++ b/compiler/GHC/Tc/Gen/Splice.hs
@@ -2641,8 +2641,8 @@ reifyTypes = mapM reifyType
 reifyPatSynType
   :: ([InvisTVBinder], ThetaType, [InvisTVBinder], ThetaType, [Scaled Type], Type) -> TcM TH.Type
 -- reifies a pattern synonym's type and returns its *complete* type
--- signature; see NOTE [Pattern synonym signatures and Template
--- Haskell]
+-- signature; see Note [Pattern synonym type signatures and Template
+-- Haskell] in GHC.ThToHs
 reifyPatSynType (univTyVars, req, exTyVars, prov, argTys, resTy)
   = do { univTyVars' <- reifyTyVarBndrs univTyVars
        ; req'        <- reifyCxt req
diff --git a/compiler/GHC/Tc/Solver.hs b/compiler/GHC/Tc/Solver.hs
index 6f783a6182..6811d35ed0 100644
--- a/compiler/GHC/Tc/Solver.hs
+++ b/compiler/GHC/Tc/Solver.hs
@@ -2689,7 +2689,7 @@ code, but:
 
    Moreover, if we simplify this implication more than once
    (e.g. because we can't solve it completely on the first iteration
-   of simpl_looop), we'll generate all the same bindings AGAIN!
+   of simpl_loop), we'll generate all the same bindings AGAIN!
 
 Easy solution: take advantage of the work we are doing to track dead
 (unused) Givens, and use it to prune the Given bindings too.  This is
diff --git a/compiler/GHC/Tc/Solver/Canonical.hs b/compiler/GHC/Tc/Solver/Canonical.hs
index 86569a8109..6622c67a4b 100644
--- a/compiler/GHC/Tc/Solver/Canonical.hs
+++ b/compiler/GHC/Tc/Solver/Canonical.hs
@@ -321,7 +321,7 @@ Why do we do this?  Two reasons:
 * To avoid repeated work, by repeatedly expanding the superclasses of
   same constraint,
 
-* To terminate the above loop, at least in the -XNoRecursiveSuperClasses
+* To terminate the above loop, at least in the -XNoUndecidableSuperClasses
   case.  If there are recursive superclasses we could, in principle,
   expand forever, always encountering new constraints.
 
diff --git a/compiler/GHC/Tc/TyCl.hs b/compiler/GHC/Tc/TyCl.hs
index 00cfe6d02b..67697eb55e 100644
--- a/compiler/GHC/Tc/TyCl.hs
+++ b/compiler/GHC/Tc/TyCl.hs
@@ -4566,7 +4566,7 @@ checkNewDataCon con
     ok_mult _   = False
 
 
--- | Reject nullary data constructors where a type variables
+-- | Reject nullary data constructors where a type variable
 -- would escape through the result kind
 -- See Note [Check for escaping result kind]
 checkEscapingKind :: DataCon -> TcM ()
diff --git a/compiler/GHC/Tc/TyCl/Instance.hs b/compiler/GHC/Tc/TyCl/Instance.hs
index 86b8626d50..879280d203 100644
--- a/compiler/GHC/Tc/TyCl/Instance.hs
+++ b/compiler/GHC/Tc/TyCl/Instance.hs
@@ -1132,7 +1132,7 @@ But what about this?
 
 So what kind do 'p' and 'q' have?  No clues from the header, but from
 the data constructor we can clearly see that (r :: Type->Type).  Does
-that mean that the the /entire data instance/ is instantiated at Type,
+that mean that the /entire data instance/ is instantiated at Type,
 like this?
    data instance T @Type (p :: Type->Type) (q :: Type) where
       ...
diff --git a/compiler/GHC/Tc/Types/Evidence.hs b/compiler/GHC/Tc/Types/Evidence.hs
index 82e7847b02..87e6bc5b82 100644
--- a/compiler/GHC/Tc/Types/Evidence.hs
+++ b/compiler/GHC/Tc/Types/Evidence.hs
@@ -565,7 +565,7 @@ data EvTerm
 type EvExpr = CoreExpr
 
 -- An EvTerm is (usually) constructed by any of the constructors here
--- and those more complicates ones who were moved to module GHC.Tc.Types.EvTerm
+-- and those more complicated ones who were moved to module GHC.Tc.Types.EvTerm
 
 -- | Any sort of evidence Id, including coercions
 evId ::  EvId -> EvExpr
@@ -671,7 +671,7 @@ evidence
     dl :: Typeable [a] = EvTypeable [a]
                             (EvTypeableTyApp (EvTypeableTyCon []) (EvId d))
 where
-    d :: Typable a
+    d :: Typeable a
 is the lambda-bound dictionary passed into f.
 
 Note [Coercion evidence terms]
diff --git a/compiler/GHC/Tc/Utils/Env.hs b/compiler/GHC/Tc/Utils/Env.hs
index 84b9d8f9a0..5f73a56724 100644
--- a/compiler/GHC/Tc/Utils/Env.hs
+++ b/compiler/GHC/Tc/Utils/Env.hs
@@ -853,7 +853,7 @@ good reasons; a view pattern in the RHS may mention a value binding).
 It is entirely reasonable to reject this, but to do so we need A to be
 in the kind environment when kind-checking the signature for B.
 
-Hence tcAddPatSynPlaceholers adds a binding
+Hence tcAddPatSynPlaceholders adds a binding
     A -> APromotionErr PatSynPE
 to the environment. Then GHC.Tc.Gen.HsType.tcTyVar will find A in the kind
 environment, and will give a 'wrongThingErr' as a result.  But the
@@ -961,7 +961,7 @@ tcGetDefaultTys
                                 -- User-supplied defaults
            Nothing  -> do
 
-        -- No use-supplied default
+        -- No user-supplied default
         -- Use [Integer, Double], plus modifications
         { integer_ty <- tcMetaTy integerTyConName
         ; list_ty <- tcMetaTy listTyConName
diff --git a/compiler/GHC/Tc/Utils/Instantiate.hs b/compiler/GHC/Tc/Utils/Instantiate.hs
index 1d47b9610e..6aa02e4788 100644
--- a/compiler/GHC/Tc/Utils/Instantiate.hs
+++ b/compiler/GHC/Tc/Utils/Instantiate.hs
@@ -219,7 +219,7 @@ topInstantiate orig sigma
 instantiateSigma :: CtOrigin -> [TyVar] -> TcThetaType -> TcSigmaType
                  -> TcM ([TcTyVar], HsWrapper, TcSigmaType)
 -- (instantiate orig tvs theta ty)
--- instantiates the the type variables tvs, emits the (instantiated)
+-- instantiates the type variables tvs, emits the (instantiated)
 -- constraints theta, and returns the (instantiated) type ty
 instantiateSigma orig tvs theta body_ty
   = do { (subst, inst_tvs) <- mapAccumLM newMetaTyVarX empty_subst tvs
diff --git a/compiler/GHC/Tc/Utils/Unify.hs b/compiler/GHC/Tc/Utils/Unify.hs
index af71c50156..d013753bae 100644
--- a/compiler/GHC/Tc/Utils/Unify.hs
+++ b/compiler/GHC/Tc/Utils/Unify.hs
@@ -1156,7 +1156,7 @@ The DeepSubsumption extension, documented here
     https://github.com/ghc-proposals/ghc-proposals/pull/511.
 
 makes a best-efforts attempt implement deep subsumption as it was
-prior to the the Simplify Subsumption proposal:
+prior to the Simplify Subsumption proposal:
 
     https://github.com/ghc-proposals/ghc-proposals/pull/287
 
diff --git a/compiler/GHC/Tc/Validity.hs b/compiler/GHC/Tc/Validity.hs
index 3fbe32352b..9af0fbdeb5 100644
--- a/compiler/GHC/Tc/Validity.hs
+++ b/compiler/GHC/Tc/Validity.hs
@@ -1091,7 +1091,7 @@ check_pred_help under_syn env dflags ctxt pred
         | otherwise           -> check_class_pred env dflags ctxt pred cls tys
 
       EqPred _ _ _      -> pprPanic "check_pred_help" (ppr pred)
-              -- EqPreds, such as (t1 ~ #t2) or (t1 ~R# t2), don't even have kind Constraint
+              -- EqPreds, such as (t1 ~# t2) or (t1 ~R# t2), don't even have kind Constraint
               -- and should never appear before the '=>' of a type.  Thus
               --     f :: (a ~# b) => blah
               -- is wrong.  For user written signatures, it'll be rejected by kind-checking
@@ -1742,7 +1742,7 @@ checkValidInstance ctxt hs_type ty
         ; expand <- initialExpandMode
         ; check_valid_theta env0 ctxt expand theta
 
-        -- The Termination and Coverate Conditions
+        -- The Termination and Coverage Conditions
         -- Check that instance inference will terminate (if we care)
         -- For Haskell 98 this will already have been done by checkValidTheta,
         -- but as we may be using other extensions we need to check.
@@ -2557,7 +2557,7 @@ In every case, b is a type variable not determined by the LHS pattern. The
 first is caught by the renamer, but we catch the last two here. Perhaps one
 could argue that the second should be accepted, albeit with a warning, but
 consider the fact that in a type family instance, there is no way to interact
-with such a varable. At least with @x :: forall a. Int@ we can use visible
+with such a variable. At least with @x :: forall a. Int@ we can use visible
 type application, like @x \@Bool 1@. (Of course it does nothing, but it is
 permissible.) In the type family case, the only sensible explanation is that
 the user has made a mistake -- thus we throw an error.
diff --git a/compiler/GHC/Types/ForeignCall.hs b/compiler/GHC/Types/ForeignCall.hs
index 9ea0917fc5..41918f34db 100644
--- a/compiler/GHC/Types/ForeignCall.hs
+++ b/compiler/GHC/Types/ForeignCall.hs
@@ -153,7 +153,7 @@ stdcall:        Caller allocates parameters, callee deallocates.
 See: http://www.programmersheaven.com/2/Calling-conventions
 -}
 
--- any changes here should be replicated in the CallConv type in template haskell
+-- any changes here should be replicated in the Callconv type in template haskell
 data CCallConv
   = CCallConv
   | CApiConv
diff --git a/compiler/GHC/Types/Id/Make.hs b/compiler/GHC/Types/Id/Make.hs
index 7b7c2d6021..59452d2912 100644
--- a/compiler/GHC/Types/Id/Make.hs
+++ b/compiler/GHC/Types/Id/Make.hs
@@ -1502,7 +1502,7 @@ oneShotId = pcMiscPrelId oneShotName ty info
 {- Note [Wired-in Ids for rebindable syntax]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The functions leftSectionId, rightSectionId are
-wired in here ONLY because they are use in a representation-polymorphic way
+wired in here ONLY because they are used in a representation-polymorphic way
 by the rebindable syntax mechanism. See GHC.Rename.Expr
 Note [Handling overloaded and rebindable constructs].
 
diff --git a/compiler/GHC/Types/Literal.hs b/compiler/GHC/Types/Literal.hs
index fffb819a39..199d744034 100644
--- a/compiler/GHC/Types/Literal.hs
+++ b/compiler/GHC/Types/Literal.hs
@@ -1013,7 +1013,7 @@ Wrinkles
 a) Why do we put the `Type` (of kind RuntimeRep) inside the literal?  Could
    we not instead /apply/ the literal to that RuntimeRep?  Alas no, because
    then LitRubbish :: forall (rr::RuntimeRep) (a::TYPE rr). a
-   and that's am ill-formed type because its kind is `TYPE rr`, which escapes
+   and that's an ill-formed type because its kind is `TYPE rr`, which escapes
    the binding site of `rr`. Annoying.
 
 b) A rubbish literal is not bottom, and replies True to exprOkForSpeculation.
@@ -1045,7 +1045,7 @@ undefined behavior, of course, but let us list a few examples for failure modes:
  a) For an value of unboxed numeric type like `Int#`, we just use a silly
     value like 42#. The error might propagate indefinitely, hence we better
     pick a rather unique literal. Same for Word, Floats, Char and VecRep.
- b) For AddrRep (like String lits), we mit a null pointer, resulting in a
+ b) For AddrRep (like String lits), we emit a null pointer, resulting in a
     definitive segfault when accessed.
  c) For boxed values, unlifted or not, we use a pointer to a fixed closure,
     like `()`, so that the GC has a pointer to follow.
diff --git a/compiler/GHC/Types/Unique/Supply.hs b/compiler/GHC/Types/Unique/Supply.hs
index 26df32b535..0e8c562a5b 100644
--- a/compiler/GHC/Types/Unique/Supply.hs
+++ b/compiler/GHC/Types/Unique/Supply.hs
@@ -98,7 +98,7 @@ This is important for example in the simplifier. Most passes of the simplifier u
 the same mask 's'. However in some places we create a unique supply using `mkSplitUniqSupply`
 and thread it through the code, while in GHC.Core.Opt.Simplify.Monad  we use the
 `instance MonadUnique SimplM`, which uses `mkSplitUniqSupply` in getUniqueSupplyM
-and `uniqFromMask` in getUniqeM.
+and `uniqFromMask` in getUniqueM.
 
 Ultimately all these boil down to each new unique consisting of the mask and the result from
 a call to `genSym`. The later producing a distinct number for each invocation ensuring
diff --git a/compiler/GHC/Utils/Logger.hs b/compiler/GHC/Utils/Logger.hs
index 7cafeae2ff..cb79b7320b 100644
--- a/compiler/GHC/Utils/Logger.hs
+++ b/compiler/GHC/Utils/Logger.hs
@@ -409,7 +409,7 @@ defaultDumpAction dumps log_action logflags sty flag title _fmt doc =
 -- | Write out a dump.
 --
 -- If --dump-to-file is set then this goes to a file.
--- otherwise emit to stdout (via the the LogAction parameter).
+-- otherwise emit to stdout (via the LogAction parameter).
 --
 -- When @hdr@ is empty, we print in a more compact format (no separators and
 -- blank lines)
diff --git a/compiler/GHC/Utils/Monad.hs b/compiler/GHC/Utils/Monad.hs
index a0cac350fe..d814fe9c92 100644
--- a/compiler/GHC/Utils/Monad.hs
+++ b/compiler/GHC/Utils/Monad.hs
@@ -346,7 +346,7 @@ smart constructor alone we still need the data constructor in
 patterns.)  That's the advantage of the pattern-synonym approach, but
 it is more elaborate.
 
-The pattern synonym approach is due to Sebastian Graaf (#18238)
+The pattern synonym approach is due to Sebastian Graf (#18238)
 
 Do note that for monads for multiple arguments more than one oneShot
 function might be required. For example in FCode we use:
@@ -426,7 +426,7 @@ replaced by (expensive x), but full laziness should pull it back out.
 The magic `inline` function does two things
 * It prevents eta reduction.  If we wrote just
       multiShotIO (IO m) = IO (\s -> m s)
-  the lamda would eta-reduce to 'm' and all would be lost.
+  the lambda would eta-reduce to 'm' and all would be lost.
 
 * It helps ensure that 'm' really does inline.
 
diff --git a/compiler/GHC/Utils/Outputable.hs b/compiler/GHC/Utils/Outputable.hs
index 1d8b962f71..4c5eedab34 100644
--- a/compiler/GHC/Utils/Outputable.hs
+++ b/compiler/GHC/Utils/Outputable.hs
@@ -363,7 +363,7 @@ data SDocContext = SDC
   , sdocLineLength                  :: !Int
   , sdocCanUseUnicode               :: !Bool
       -- ^ True if Unicode encoding is supported
-      -- and not disable by GHC_NO_UNICODE environment variable
+      -- and not disabled by GHC_NO_UNICODE environment variable
   , sdocHexWordLiterals             :: !Bool
   , sdocPprDebug                    :: !Bool
   , sdocPrintUnicodeSyntax          :: !Bool
diff --git a/docs/users_guide/debugging.rst b/docs/users_guide/debugging.rst
index 87a689c268..83d093cd06 100644
--- a/docs/users_guide/debugging.rst
+++ b/docs/users_guide/debugging.rst
@@ -980,8 +980,8 @@ Checking for consistency
     :type: dynamic
 
     Turn on linearity checking in GHC. Currently, some optimizations
-    in GHC might not preserve linearity and they valid programs might
-    fail Linear Core Lint.
+    in GHC might not preserve linearity and there are valid programs
+    that fail Linear Core Lint.
     In the near future, this option will be removed and folded into
     normal Core Lint.
 
diff --git a/docs/users_guide/exts/existential_quantification.rst b/docs/users_guide/exts/existential_quantification.rst
index 87b15acd0d..568eb63b7b 100644
--- a/docs/users_guide/exts/existential_quantification.rst
+++ b/docs/users_guide/exts/existential_quantification.rst
@@ -248,7 +248,7 @@ constructors can be used.
 
 -  You can't use ``deriving`` to define instances of a data type with
    existentially quantified data constructors. Reason: in most cases it
-   would not make sense. For example:; ::
+   would not make sense. For example: ::
 
        data T = forall a. MkT [a] deriving( Eq )
 
diff --git a/docs/users_guide/exts/lambda_case.rst b/docs/users_guide/exts/lambda_case.rst
index ca648fa904..4712da3d74 100644
--- a/docs/users_guide/exts/lambda_case.rst
+++ b/docs/users_guide/exts/lambda_case.rst
@@ -18,7 +18,7 @@ which is equivalent to ::
 
       \freshName -> case freshName of { p1 -> e1; ...; pN -> eN }
 
-Since GHC 9.4.1, it also allow expressions with multiple scrutinees (see GHC
+Since GHC 9.4.1, it also allows expressions with multiple scrutinees (see GHC
 proposal `#302 <https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0302-cases.rst>`_)
 of the form ::
 
diff --git a/docs/users_guide/exts/qualified_do.rst b/docs/users_guide/exts/qualified_do.rst
index 71c43c5655..050a5bfce6 100644
--- a/docs/users_guide/exts/qualified_do.rst
+++ b/docs/users_guide/exts/qualified_do.rst
@@ -85,7 +85,7 @@ The semantics of ``do`` notation statements with ``-XQualifiedDo`` is as follows
     M.do { pat <- u; stmts }  =  u M.>>= \case pat -> M.do { stmts }
 
 *  The desugaring of ``-XApplicativeDo`` uses ``M.fmap``, ``(M.<*>)``,
-   and ``M.join`` (after the the applicative-do grouping has been performed) ::
+   and ``M.join`` (after the applicative-do grouping has been performed) ::
 
     M.do { (x1 <- u1 | … | xn <- un); M.return e }  =
       (\x1 … xn -> e) `M.fmap` u1 M.<*> … M.<*> un
diff --git a/docs/users_guide/exts/record_field_resolution.rst b/docs/users_guide/exts/record_field_resolution.rst
index 3209387d26..fba686d42a 100644
--- a/docs/users_guide/exts/record_field_resolution.rst
+++ b/docs/users_guide/exts/record_field_resolution.rst
@@ -21,7 +21,7 @@ Those rules are amended by the following extensions:
 * :extension:`DisambiguateRecordFields`: In record construction and pattern matching
   (``C{ x = …}``), an unqualified field name ``x`` is unambiguous if and only if the data constructor (``C``)
   has a field ``x``, and that field is in scope unqualified, or qualified as ``Q.x``, regardless of ``Q``.
-  Similarly, in record construction and pattern matching, a qualified field name ``M.x`` is unambiguous if and only if the the data
+  Similarly, in record construction and pattern matching, a qualified field name ``M.x`` is unambiguous if and only if the data
   constructor (``C``) has a field ``x``, and that field is in scope qualified as ``M.x``.
 
   In record updates (``r{ x = 3 }``), the field name x is unambiguous if and only if there is just one field name x in scope unqualified.
@@ -51,7 +51,7 @@ refer unambiguously to data type ``S``.
     data T = MkT { x :: Int }
 
     x :: String
-    x = "Hello
+    x = "Hello"
 
     f = x
 
diff --git a/docs/users_guide/exts/record_wildcards.rst b/docs/users_guide/exts/record_wildcards.rst
index d926a85b39..aff4cccf73 100644
--- a/docs/users_guide/exts/record_wildcards.rst
+++ b/docs/users_guide/exts/record_wildcards.rst
@@ -75,7 +75,7 @@ More details:
    ``c`` is not in scope (apart from the binding of the record selector
    ``c``, of course).
 
--  When record wildcards are use in record construction, a field ``f``
+-  When record wildcards are used in record construction, a field ``f``
    is initialised only if ``f`` is in scope,
    and is not imported or bound at top level.
    For example, ``f`` can be bound by an enclosing pattern match or
diff --git a/docs/users_guide/using-optimisation.rst b/docs/users_guide/using-optimisation.rst
index 02f1fd50f6..b5f8c5bb29 100644
--- a/docs/users_guide/using-optimisation.rst
+++ b/docs/users_guide/using-optimisation.rst
@@ -335,7 +335,7 @@ by saying ``-fno-wombat``.
 
     CPR analysis will see that each code path produces a *constructed product*
     such as ``I# 0#`` in the first branch (where ``GHC.Exts.I#`` is the data
-    constructor of ``Int``, boxing up the the primitive integer literal ``0#``
+    constructor of ``Int``, boxing up the primitive integer literal ``0#``
     of type ``Int#``) and optimise to ::
 
          sum xs = I# ($wsum xs)
diff --git a/libraries/base/Data/Typeable/Internal.hs b/libraries/base/Data/Typeable/Internal.hs
index 69530c911d..9bcc23daf5 100644
--- a/libraries/base/Data/Typeable/Internal.hs
+++ b/libraries/base/Data/Typeable/Internal.hs
@@ -214,7 +214,7 @@ data TypeRep a where
                , trAppKind :: !(TypeRep k2) }   -- See Note [Kind caching]
             -> TypeRep (a b)
 
-    -- | @TrFun fpr m a b@ represents a function type @a # m -> b@. We use this for
+    -- | @TrFun fpr m a b@ represents a function type @a % m -> b@. We use this for
     -- the sake of efficiency as functions are quite ubiquitous.
     TrFun   :: forall (m :: Multiplicity) (r1 :: RuntimeRep) (r2 :: RuntimeRep)
                       (a :: TYPE r1) (b :: TYPE r2).
diff --git a/libraries/base/GHC/IOPort.hs b/libraries/base/GHC/IOPort.hs
index 46a553ca51..101f9b34fa 100644
--- a/libraries/base/GHC/IOPort.hs
+++ b/libraries/base/GHC/IOPort.hs
@@ -96,7 +96,7 @@ newIOPort value =
     writeIOPort ioport value  >>
     return ioport
 
--- |Atomically read the the contents of the 'IOPort'.  If the 'IOPort' is
+-- |Atomically read the contents of the 'IOPort'.  If the 'IOPort' is
 -- currently empty, 'readIOPort' will wait until it is full.  After a
 -- 'readIOPort', the 'IOPort' is left empty.
 --
diff --git a/testsuite/tests/cpranal/should_compile/T18174.hs b/testsuite/tests/cpranal/should_compile/T18174.hs
index 69ca25a19e..84a72b747b 100644
--- a/testsuite/tests/cpranal/should_compile/T18174.hs
+++ b/testsuite/tests/cpranal/should_compile/T18174.hs
@@ -75,7 +75,7 @@ h1 m = uncurry (+) (g1 m)
 --
 -- > #c1(#c1(#), *c1(#))
 --
--- In combination with the the fact that all calls to @g2@ evaluate the second
+-- In combination with the fact that all calls to @g2@ evaluate the second
 -- component of the pair, we may unbox @g2@ to @(# Int#, Int# #)@.
 --
 -- Nested CPR light doesn't manage to unbox the second component, though.
diff --git a/testsuite/tests/ghc-api/exactprint/WhereIn4.expected.hs b/testsuite/tests/ghc-api/exactprint/WhereIn4.expected.hs
index 4357bfdac7..837139e516 100644
--- a/testsuite/tests/ghc-api/exactprint/WhereIn4.expected.hs
+++ b/testsuite/tests/ghc-api/exactprint/WhereIn4.expected.hs
@@ -6,7 +6,7 @@ module WhereIn4 where
 --Demoting a definition narrows down the scope of the definition.
 --In this example, demote the top level 'sq' to 'sumSquares'
 --In this case (there is single matches), if possible,
---the parameters will be folded after demoting and type sigature will be removed.
+--the parameters will be folded after demoting and type signature will be removed.
 
 sumSquares x y = sq p x + sq p y
          where p_2=2  {-There is a comment-}
diff --git a/testsuite/tests/ghc-api/exactprint/WhereIn4.hs b/testsuite/tests/ghc-api/exactprint/WhereIn4.hs
index 8b941fff4a..d929e806cc 100644
--- a/testsuite/tests/ghc-api/exactprint/WhereIn4.hs
+++ b/testsuite/tests/ghc-api/exactprint/WhereIn4.hs
@@ -6,7 +6,7 @@ module WhereIn4 where
 --Demoting a definition narrows down the scope of the definition.
 --In this example, demote the top level 'sq' to 'sumSquares'
 --In this case (there is single matches), if possible,
---the parameters will be folded after demoting and type sigature will be removed.
+--the parameters will be folded after demoting and type signature will be removed.
 
 sumSquares x y = sq p x + sq p y
          where p=2  {-There is a comment-}
diff --git a/testsuite/tests/linters/notes.stdout b/testsuite/tests/linters/notes.stdout
index c46f0edd95..ac7a453445 100644
--- a/testsuite/tests/linters/notes.stdout
+++ b/testsuite/tests/linters/notes.stdout
@@ -18,6 +18,7 @@ ref    compiler/GHC/HsToCore/Binds.hs:312:33:     Note [AbsBinds wrappers]
 ref    compiler/GHC/HsToCore/Pmc/Solver.hs:854:20:     Note [COMPLETE sets on data families]
 ref    compiler/GHC/HsToCore/Quote.hs:1460:7:     Note [How brackets and nested splices are handled]
 ref    compiler/GHC/Rename/Pat.hs:888:29:     Note [Disambiguating record fields]
+ref    compiler/GHC/Stg/Unarise.hs:313:32:     Note [Renaming during unarisation]
 ref    compiler/GHC/StgToCmm.hs:106:18:     Note [codegen-split-init]
 ref    compiler/GHC/StgToCmm.hs:109:18:     Note [pipeline-split-init]
 ref    compiler/GHC/StgToCmm/Expr.hs:584:4:     Note [case on bool]
diff --git a/testsuite/tests/th/T6018th.hs b/testsuite/tests/th/T6018th.hs
index 41e0b5e607..4fa0eb3716 100644
--- a/testsuite/tests/th/T6018th.hs
+++ b/testsuite/tests/th/T6018th.hs
@@ -33,7 +33,7 @@ $( return
                  (ConT (mkName "Char")))
    ] )
 
--- this is injective - a type variables mentioned on LHS is not mentioned on RHS
+-- this is injective - a type variable mentioned on LHS is not mentioned on RHS
 -- but we don't claim injectivity in that argument.
 --
 -- type family J a (b :: k) = r | r -> a