diff options
85 files changed, 113 insertions, 113 deletions
diff --git a/compiler/GHC.hs b/compiler/GHC.hs index 5d8b295b95..eef40f6c2b 100644 --- a/compiler/GHC.hs +++ b/compiler/GHC.hs @@ -857,7 +857,7 @@ looks_like_an_input m = isSourceFilename m -- away. Note the asymmetry of FilePath.normalise: -- Linux: p\/q -> p\/q; p\\q -> p\\q -- Windows: p\/q -> p\\q; p\\q -> p\\q --- #12674: Filenames starting with a hypen get normalised from ./-foo.hs +-- #12674: Filenames starting with a hyphen get normalised from ./-foo.hs -- to -foo.hs. We have to re-prepend the current directory. normalise_hyp :: FilePath -> FilePath normalise_hyp fp diff --git a/compiler/GHC/Builtin/PrimOps.hs b/compiler/GHC/Builtin/PrimOps.hs index 4ad8652922..14040692bc 100644 --- a/compiler/GHC/Builtin/PrimOps.hs +++ b/compiler/GHC/Builtin/PrimOps.hs @@ -634,7 +634,7 @@ Note [Eta expanding primops] STG requires that primop applications be saturated. This makes code generation significantly simpler since otherwise we would need to define a calling -convention for curried applications that can accomodate levity polymorphism. +convention for curried applications that can accommodate levity polymorphism. To ensure saturation, CorePrep eta expands expand all primop applications as described in Note [Eta expansion of hasNoBinding things in CorePrep] in diff --git a/compiler/GHC/Cmm/CLabel.hs b/compiler/GHC/Cmm/CLabel.hs index 75559edd2e..4b30bc8cf1 100644 --- a/compiler/GHC/Cmm/CLabel.hs +++ b/compiler/GHC/Cmm/CLabel.hs @@ -1378,7 +1378,7 @@ pprCLabel platform sty lbl = -- Note that these labels are *not* referred to by code. They are strictly for -- diagnostics purposes. -- --- To avoid confusion, it is desireable to add a module-qualifier to the +-- To avoid confusion, it is desirable to add a module-qualifier to the -- symbol name. However, the Name type's Internal constructor doesn't carry -- knowledge of the current Module. Consequently, we have to pass this around -- explicitly. diff --git a/compiler/GHC/Cmm/Info/Build.hs b/compiler/GHC/Cmm/Info/Build.hs index b43eaa1257..1d3431c4af 100644 --- a/compiler/GHC/Cmm/Info/Build.hs +++ b/compiler/GHC/Cmm/Info/Build.hs @@ -441,7 +441,7 @@ counters are not exported. So we ignore ticky counters in SRT analysis (which are never CAFFY and never exported). Not doing this caused #17947 where we analysed the function first mapped the -name to CAFFY. We then saw the ticky constructor, and becuase it has the same +name to CAFFY. We then saw the ticky constructor, and because it has the same Name as the function and is not CAFFY we overrode the CafInfo of the name as non-CAFFY. -} diff --git a/compiler/GHC/CmmToAsm/BlockLayout.hs b/compiler/GHC/CmmToAsm/BlockLayout.hs index b7c6ffb098..d7314eaa5b 100644 --- a/compiler/GHC/CmmToAsm/BlockLayout.hs +++ b/compiler/GHC/CmmToAsm/BlockLayout.hs @@ -539,7 +539,7 @@ mergeChains edges chains -- An Edge is irrelevant if the ends are part of the same chain. -- We say these edges are already linked buildChains :: [CfgEdge] -> [BlockId] - -> ( LabelMap BlockChain -- Resulting chains, indexd by end if chain. + -> ( LabelMap BlockChain -- Resulting chains, indexed by end if chain. , Set.Set (BlockId, BlockId)) --List of fused edges. buildChains edges blocks = runST $ buildNext setEmpty mapEmpty mapEmpty edges Set.empty diff --git a/compiler/GHC/CmmToAsm/Reg/Graph/Base.hs b/compiler/GHC/CmmToAsm/Reg/Graph/Base.hs index a06934c837..32b49a61e8 100644 --- a/compiler/GHC/CmmToAsm/Reg/Graph/Base.hs +++ b/compiler/GHC/CmmToAsm/Reg/Graph/Base.hs @@ -141,7 +141,7 @@ bound regsOfClass regAlias classN classesC -- | The total squeese on a particular node with a list of neighbors. -- -- A version of this should be constructed for each particular architecture, --- possibly including uses of bound, so that alised registers don't get +-- possibly including uses of bound, so that aliased registers don't get -- counted twice, as per the paper. squeese :: (RegClass -> UniqSet Reg) -> (Reg -> UniqSet Reg) diff --git a/compiler/GHC/CmmToAsm/X86/CodeGen.hs b/compiler/GHC/CmmToAsm/X86/CodeGen.hs index 3883d44717..36b24e8be2 100644 --- a/compiler/GHC/CmmToAsm/X86/CodeGen.hs +++ b/compiler/GHC/CmmToAsm/X86/CodeGen.hs @@ -3054,7 +3054,7 @@ genCCall32' target dest_regs args = do X87Store fmt tmp_amode, -- X87Store only supported for the CDECL ABI -- NB: This code will need to be - -- revisted once GHC does more work around + -- revisited once GHC does more work around -- SIGFPE f MOV fmt (OpAddr tmp_amode) (OpReg r_dest), ADD II32 (OpImm (ImmInt b)) (OpReg esp), diff --git a/compiler/GHC/Core/Lint.hs b/compiler/GHC/Core/Lint.hs index f014a20817..f1720725a6 100644 --- a/compiler/GHC/Core/Lint.hs +++ b/compiler/GHC/Core/Lint.hs @@ -212,14 +212,14 @@ in GHC.Core.Opt.WorkWrap.Utils. (Maybe there are other "clients" of this featur * Alas, when cloning a coercion variable we might choose a unique that happens to clash with an inner Id, thus \cv_66 -> let wild_X7 = blah in blah - We decide to clone `cv_66` becuase it's already in scope. Fine, + We decide to clone `cv_66` because it's already in scope. Fine, choose a new unique. Aha, X7 looks good. So we check the lambda body with le_subst of [cv_66 :-> cv_X7] This is all fine, even though we use the same unique as wild_X7. As (SI2) says, we do /not/ return a new lambda (\cv_X7 -> let wild_X7 = blah in ...) - We simply use the le_subst subsitution in types/coercions only, when + We simply use the le_subst substitution in types/coercions only, when checking for equality. * We still need to check that Id occurrences are bound by some diff --git a/compiler/GHC/Core/Opt/Arity.hs b/compiler/GHC/Core/Opt/Arity.hs index 99cfd1b15f..6dd1148e56 100644 --- a/compiler/GHC/Core/Opt/Arity.hs +++ b/compiler/GHC/Core/Opt/Arity.hs @@ -682,7 +682,7 @@ This example happens a lot; it first showed up in Andy Gill's thesis, fifteen years ago! It also shows up in the code for 'rnf' on lists in #4138. -We do the neccessary, quite simple fixed-point iteration in 'findRhsArity', +We do the necessary, quite simple fixed-point iteration in 'findRhsArity', which assumes for a single binding 'ABot' on the first run and iterates until it finds a stable arity type. Two wrinkles @@ -1339,7 +1339,7 @@ a (\eta) around the outside and use etaInfoApp to apply each alternative to 'eta'. We want to beta-reduce all that junk away. -#18223 was a dramtic example in which the intermediate term was +#18223 was a dramatic example in which the intermediate term was grotesquely huge, even though the next Simplifier iteration squashed it. Better to kill it at birth. -} diff --git a/compiler/GHC/Core/Opt/DmdAnal.hs b/compiler/GHC/Core/Opt/DmdAnal.hs index 3eb86852ac..413da0794a 100644 --- a/compiler/GHC/Core/Opt/DmdAnal.hs +++ b/compiler/GHC/Core/Opt/DmdAnal.hs @@ -177,7 +177,7 @@ That is, a series of right-nested pairs, where the @fst@ are the exported binders of the last enclosing let binding and @snd@ continues the nested lets. -Variables occuring free in RULE RHSs are to be handled the same as exported Ids. +Variables occurring free in RULE RHSs are to be handled the same as exported Ids. See also Note [Absence analysis for stable unfoldings and RULES]. Note [Why care for top-level demand annotations?] @@ -204,7 +204,7 @@ to unbox deeper. From T18894: h m = ... snd (g m 2) ... uncurry (+) (g 2 m) ... Only @h@ is exported, hence we see that @g@ is always called in contexts were we also force the division in the second component of the pair returned by @g@. -This allows Nested CPR to evalute the division eagerly and return an I# in its +This allows Nested CPR to evaluate the division eagerly and return an I# in its position. -} @@ -1181,7 +1181,7 @@ For (2) consider f _ (MkT n t) = f n t Here f is lazy in T, but its *usage* is infinite: U(U,U(U,U(U, ...))). -Notice that this happens becuase T is a product type, and is recrusive. +Notice that this happens because T is a product type, and is recrusive. If we are not careful, we'll fail to iterate to a fixpoint in dmdFix, and bale out entirely, which is inefficient and over-conservative. diff --git a/compiler/GHC/Core/Opt/OccurAnal.hs b/compiler/GHC/Core/Opt/OccurAnal.hs index 343ddfe618..c5c5e4207a 100644 --- a/compiler/GHC/Core/Opt/OccurAnal.hs +++ b/compiler/GHC/Core/Opt/OccurAnal.hs @@ -302,7 +302,7 @@ in Note [IMP-RULES: local rules for imported functions]. So, during loop-breaker analysis: -- for each active RULE for a local function 'f' we add an edge bewteen +- for each active RULE for a local function 'f' we add an edge between 'f' and the local FVs of the rule RHS - for each active RULE for an *imported* function we add dependency @@ -639,7 +639,7 @@ propagate. {-# RULES "SPEC k 0" k 0 = j #-} k x y = x + 2 * y in ... - If we eta-expanded the rule all woudl be well, but as it stands the + If we eta-expanded the rule all would be well, but as it stands the one arg of the rule don't match the join-point arity of 2. Conceivably we could notice that a potential join point would have diff --git a/compiler/GHC/Core/Opt/Simplify.hs b/compiler/GHC/Core/Opt/Simplify.hs index 97173eee5c..0cea6da0bf 100644 --- a/compiler/GHC/Core/Opt/Simplify.hs +++ b/compiler/GHC/Core/Opt/Simplify.hs @@ -3653,7 +3653,7 @@ Pushing the call inward (being careful not to duplicate E) and now the (&& a F) etc can optimise. Moreover there might be a RULE for the function that can fire when it "sees" the -particular case alterantive. +particular case alternative. But Plan A can have terrible, terrible behaviour. Here is a classic case: diff --git a/compiler/GHC/Core/Opt/Simplify/Utils.hs b/compiler/GHC/Core/Opt/Simplify/Utils.hs index 2ab7fe2e28..191e72e3b2 100644 --- a/compiler/GHC/Core/Opt/Simplify/Utils.hs +++ b/compiler/GHC/Core/Opt/Simplify/Utils.hs @@ -1479,7 +1479,7 @@ different way (Note [Duplicating StrictArg] in Simplify). So I just set an arbitrary, high limit of 100, to stop any totally exponential behaviour. -This still leaves the nasty possiblity that /ordinary/ inlining (not +This still leaves the nasty possibility that /ordinary/ inlining (not postInlineUnconditionally) might inline these join points, each of which is individually quiet small. I'm still not sure what to do about this (e.g. see #15488). diff --git a/compiler/GHC/Core/Opt/Specialise.hs b/compiler/GHC/Core/Opt/Specialise.hs index 4ff730fa77..c2510b97c0 100644 --- a/compiler/GHC/Core/Opt/Specialise.hs +++ b/compiler/GHC/Core/Opt/Specialise.hs @@ -867,7 +867,7 @@ call to spec_imorpts in spec_import, we must include the dict-binds from the parent. Lacking this caused #17151, a really nasty bug. Here is what happened. -* Class struture: +* Class structure: Source is a superclass of Mut Index is a superclass of Source diff --git a/compiler/GHC/Core/TyCo/FVs.hs b/compiler/GHC/Core/TyCo/FVs.hs index 8277b06378..c8a7506363 100644 --- a/compiler/GHC/Core/TyCo/FVs.hs +++ b/compiler/GHC/Core/TyCo/FVs.hs @@ -383,7 +383,7 @@ shallowTcvFolder = TyCoFolder { tcf_view = noView {- Note [Finding free coercion varibles] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Here we are only interested in the free /coercion/ variables. -We can achieve this through a slightly differnet TyCo folder. +We can achieve this through a slightly different TyCo folder. Notice that we look deeply, into kinds. diff --git a/compiler/GHC/Core/TyCo/Rep.hs b/compiler/GHC/Core/TyCo/Rep.hs index 69db14e7f0..7414bc18da 100644 --- a/compiler/GHC/Core/TyCo/Rep.hs +++ b/compiler/GHC/Core/TyCo/Rep.hs @@ -1909,7 +1909,7 @@ foldTyCo (TyCoFolder { tcf_view = view = let !env' = tycobinder env tv vis -- Avoid building a thunk here in go_ty env (varType tv) `mappend` go_ty env' inner - -- Explicit recursion becuase using foldr builds a local + -- Explicit recursion because using foldr builds a local -- loop (with env free) and I'm not confident it'll be -- lambda lifted in the end go_tys _ [] = mempty diff --git a/compiler/GHC/Core/Type.hs b/compiler/GHC/Core/Type.hs index 21f03d653e..7032b97939 100644 --- a/compiler/GHC/Core/Type.hs +++ b/compiler/GHC/Core/Type.hs @@ -1158,7 +1158,7 @@ is equivalent to, FunTy (Anon a) b Note how the RuntimeReps are implied in the FunTy representation. For this -reason we must be careful when recontructing the TyConApp representation (see, +reason we must be careful when reconstructing the TyConApp representation (see, for instance, splitTyConApp_maybe). In the compiler we maintain the invariant that all saturated applications of diff --git a/compiler/GHC/Core/Unfold.hs b/compiler/GHC/Core/Unfold.hs index 0d0df57f57..b97e10cd46 100644 --- a/compiler/GHC/Core/Unfold.hs +++ b/compiler/GHC/Core/Unfold.hs @@ -810,7 +810,7 @@ binary sizes shrink significantly either. Note [Discounts and thresholds] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Constants for discounts and thesholds are defined in 'UnfoldingOpts'. They are: +Constants for discounts and thresholds are defined in 'UnfoldingOpts'. They are: unfoldingCreationThreshold At a definition site, if the unfolding is bigger than this, we diff --git a/compiler/GHC/Core/Unify.hs b/compiler/GHC/Core/Unify.hs index 81492afc86..dbfd4083ad 100644 --- a/compiler/GHC/Core/Unify.hs +++ b/compiler/GHC/Core/Unify.hs @@ -529,7 +529,7 @@ instance Monad UnifyResultM where SurelyApart -> SurelyApart Unifiable x >>= f = f x --- | @tcUnifyTysFG bind_tv tys1 tys2@ attepts to find a substitution @s@ (whose +-- | @tcUnifyTysFG bind_tv tys1 tys2@ attempts to find a substitution @s@ (whose -- domain elements all respond 'BindMe' to @bind_tv@) such that -- @s(tys1)@ and that of @s(tys2)@ are equal, as witnessed by the returned -- Coercions. This version requires that the kinds of the types are the same, diff --git a/compiler/GHC/CoreToStg/Prep.hs b/compiler/GHC/CoreToStg/Prep.hs index 626fcadfce..9eae6867ac 100644 --- a/compiler/GHC/CoreToStg/Prep.hs +++ b/compiler/GHC/CoreToStg/Prep.hs @@ -1028,7 +1028,7 @@ Performing the transform described above would result in: If runRW# were a "normal" function this call to join point j would not be allowed in its continuation argument. However, since runRW# is inlined (as -described in Note [runRW magic] above), such join point occurences are +described in Note [runRW magic] above), such join point occurrences are completely fine. Both occurrence analysis (see the runRW guard in occAnalApp) and Core Lint (see the App case of lintCoreExpr) have special treatment for runRW# applications. See Note [Linting of runRW#] for details on the latter. diff --git a/compiler/GHC/HsToCore/Expr.hs b/compiler/GHC/HsToCore/Expr.hs index 259615e64c..d2c5d77cbe 100644 --- a/compiler/GHC/HsToCore/Expr.hs +++ b/compiler/GHC/HsToCore/Expr.hs @@ -240,7 +240,7 @@ dsUnliftedBind bind body = pprPanic "dsLet: unlifted" (ppr bind $$ ppr body) -} --- | Replace the body of the fucntion with this block to test the hsExprType +-- | Replace the body of the function with this block to test the hsExprType -- function in GHC.Tc.Utils.Zonk: -- putSrcSpanDs loc $ do -- { core_expr <- dsExpr e @@ -682,7 +682,7 @@ We have MkF (co2::s ~# Int) _ -> $WMkF @t y |> co3 (Side note: here (z |> co1) is built by typechecking the scrutinee, so -we ignore it here. In general the scrutinee is an aribtrary expression.) +we ignore it here. In general the scrutinee is an arbitrary expression.) The question is: what is co3, the cast for the RHS? co3 :: F (Int,t) ~ F (s,t) diff --git a/compiler/GHC/Iface/UpdateIdInfos.hs b/compiler/GHC/Iface/UpdateIdInfos.hs index e37964c51d..0c70b5caeb 100644 --- a/compiler/GHC/Iface/UpdateIdInfos.hs +++ b/compiler/GHC/Iface/UpdateIdInfos.hs @@ -27,7 +27,7 @@ import GHC.Utils.Panic #include "HsVersions.h" --- | Update CafInfos and LFInfos of all occurences (in rules, unfoldings, class +-- | Update CafInfos and LFInfos of all occurrences (in rules, unfoldings, class -- instances). -- -- See Note [Conveying CAF-info and LFInfo between modules] in diff --git a/compiler/GHC/Linker/MacOS.hs b/compiler/GHC/Linker/MacOS.hs index 959ef3a217..be5cbf2f9c 100644 --- a/compiler/GHC/Linker/MacOS.hs +++ b/compiler/GHC/Linker/MacOS.hs @@ -36,7 +36,7 @@ import System.FilePath ((</>), (<.>)) -- @-l@ and @-rpath@ to the linker will result in the unnecesasry libraries not -- being included in the load commands, however the @-rpath@ entries are all -- forced to be included. This can lead to 100s of @-rpath@ entries being --- included when only a handful of libraries end up being truely linked. +-- included when only a handful of libraries end up being truly linked. -- -- Thus after building the library, we run a fixup phase where we inject the -- @-rpath@ for each found library (in the given library search paths) into the diff --git a/compiler/GHC/Parser/Errors.hs b/compiler/GHC/Parser/Errors.hs index 57c6141117..f0f4372c8a 100644 --- a/compiler/GHC/Parser/Errors.hs +++ b/compiler/GHC/Parser/Errors.hs @@ -36,8 +36,8 @@ data PsWarning -- | Warn when tabulations are found = PsWarnTab - { tabFirst :: !SrcSpan -- ^ First occurence of a tab - , tabCount :: !Word -- ^ Number of other occurences + { tabFirst :: !SrcSpan -- ^ First occurrence of a tab + , tabCount :: !Word -- ^ Number of other occurrences } | PsWarnTransitionalLayout !SrcSpan !TransLayoutReason @@ -53,7 +53,7 @@ data PsWarning -- ^ Multiple Haddock comment for the same entity | PsWarnStarBinder !SrcSpan - -- ^ Found binding occurence of "*" while StarIsType is enabled + -- ^ Found binding occurrence of "*" while StarIsType is enabled | PsWarnStarIsType !SrcSpan -- ^ Using "*" for "Type" without StarIsType enabled @@ -103,7 +103,7 @@ data PsErrorDesc -- ^ Lexer error | PsErrSuffixAT - -- ^ Suffix occurence of `@` + -- ^ Suffix occurrence of `@` | PsErrParse !String -- ^ Parse errors diff --git a/compiler/GHC/Parser/Lexer.x b/compiler/GHC/Parser/Lexer.x index aaae9077b6..5e2af15f96 100644 --- a/compiler/GHC/Parser/Lexer.x +++ b/compiler/GHC/Parser/Lexer.x @@ -2849,7 +2849,7 @@ getMessages :: PState -> (Bag PsWarning, Bag PsError) getMessages p = let ws = warnings p -- we add the tabulation warning on the fly because - -- we count the number of occurences of tab characters + -- we count the number of occurrences of tab characters ws' = case tab_first p of Nothing -> ws Just tf -> PsWarnTab (RealSrcSpan tf Nothing) (tab_count p) diff --git a/compiler/GHC/Parser/PostProcess/Haddock.hs b/compiler/GHC/Parser/PostProcess/Haddock.hs index 6741476925..43ac07a482 100644 --- a/compiler/GHC/Parser/PostProcess/Haddock.hs +++ b/compiler/GHC/Parser/PostProcess/Haddock.hs @@ -110,7 +110,7 @@ the location range in which we search for HdkCommentPrev is as follows: We search for comments after HsTyVar "Int" and until the next syntactic element, in this case HsTyVar "Bool". -Ignoring the "->" allows us to accomodate alternative coding styles: +Ignoring the "->" allows us to accommodate alternative coding styles: f :: Int -> -- ^ comment on argument Bool -- ^ comment on result @@ -1540,7 +1540,7 @@ Sometimes handling documentation comments during parsing led to bugs (#17561), and sometimes it simply made it hard to modify and extend the grammar. Another issue was that sometimes Haddock would fail to parse code -that GHC could parse succesfully: +that GHC could parse successfully: class BadIndent where f :: a -> Int diff --git a/compiler/GHC/Rename/Env.hs b/compiler/GHC/Rename/Env.hs index 6e0c19f190..19c4e4610e 100644 --- a/compiler/GHC/Rename/Env.hs +++ b/compiler/GHC/Rename/Env.hs @@ -1112,7 +1112,7 @@ lookupGlobalOccRn rdr_name = Nothing -> do { traceRn "lookupGlobalOccRn" (ppr rdr_name) ; unboundName WL_Global rdr_name } --- Looks up a RdrName occurence in the GlobalRdrEnv and with +-- Looks up a RdrName occurrence in the GlobalRdrEnv and with -- lookupQualifiedNameGHCi. Does not try to find an Exact or Orig name first. -- lookupQualifiedNameGHCi here is used when we're in GHCi and a name like -- 'Data.Map.elems' is typed, even if you didn't import Data.Map diff --git a/compiler/GHC/Runtime/Interpreter.hs b/compiler/GHC/Runtime/Interpreter.hs index 4536226bf8..cb13089571 100644 --- a/compiler/GHC/Runtime/Interpreter.hs +++ b/compiler/GHC/Runtime/Interpreter.hs @@ -202,7 +202,7 @@ iservCmd hsc_env msg = withInterp hsc_env $ \case withInterp :: HscEnv -> (Interp -> IO a) -> IO a withInterp hsc_env action = action (hscInterp hsc_env) --- | Retreive the targe code interpreter +-- | Retrieve the targe code interpreter -- -- Fails if no target code interpreter is available hscInterp :: HscEnv -> Interp diff --git a/compiler/GHC/StgToCmm/Foreign.hs b/compiler/GHC/StgToCmm/Foreign.hs index 9bae125ce5..21c85d569c 100644 --- a/compiler/GHC/StgToCmm/Foreign.hs +++ b/compiler/GHC/StgToCmm/Foreign.hs @@ -460,7 +460,7 @@ Opening the nursery corresponds to the following code: tso->alloc_limit += bdfree - bdstart; // Set Hp to the last occupied word of the heap block. Why not the - // next unocupied word? Doing it this way means that we get to use + // next unoccupied word? Doing it this way means that we get to use // an offset of zero more often, which might lead to slightly smaller // code on some architectures. Hp = bdfree - WDS(1); diff --git a/compiler/GHC/Tc/Deriv/Generate.hs b/compiler/GHC/Tc/Deriv/Generate.hs index 2bda9d40c6..0f374700dd 100644 --- a/compiler/GHC/Tc/Deriv/Generate.hs +++ b/compiler/GHC/Tc/Deriv/Generate.hs @@ -2682,7 +2682,7 @@ avoid name clashes: toEnum a = $tag2con_T{Uniq2} a -- $tag2con_T{Uniq1} and $tag2con_T{Uniq2} are Exact RdrNames with - -- underyling System Names + -- underlying System Names $tag2con_T{Uniq1} :: Int -> T $tag2con_T{Uniq1} = ...code.... diff --git a/compiler/GHC/Tc/Gen/App.hs b/compiler/GHC/Tc/Gen/App.hs index 83f8cc567d..5b34952d65 100644 --- a/compiler/GHC/Tc/Gen/App.hs +++ b/compiler/GHC/Tc/Gen/App.hs @@ -291,7 +291,7 @@ tcApp rn_expr exp_res_ty -- Zonk the result type, to ensure that we substitute out -- any filled-in instantiation variable before calling tcWrapResultMono - -- In the Check case, this isn't really necessary, becuase tcWrapResultMono + -- In the Check case, this isn't really necessary, because tcWrapResultMono -- just drops to tcUnify; but in the Infer case a filled-in instantiation -- variable might perhaps escape into the constraint generator. The safe -- thing to do is to any instantaition variables away. @@ -318,7 +318,7 @@ wantQuickLook _ = xoptM LangExt.Impredi zonkQuickLook :: Bool -> TcType -> TcM TcType -- After all Quick Look unifications are done, zonk to ensure that all --- instantation variables are substituted away +-- instantiation variables are substituted away -- -- So far as the paper is concerned, this step applies -- the poly-substitution Theta, learned by QL, so that we @@ -677,7 +677,7 @@ over any visible type arguments. We've already inferred the type of the function (in tcInferAppHead), so we'll /already/ have emitted a Hole constraint; failing preserves that constraint. -We do /not/ want to fail altogether in this case (via failM) becuase +We do /not/ want to fail altogether in this case (via failM) because that may abandon an entire instance decl, which (in the presence of -fdefer-type-errors) leads to leading to #17792. diff --git a/compiler/GHC/Tc/Gen/Bind.hs b/compiler/GHC/Tc/Gen/Bind.hs index c677643be5..c63cbabdc1 100644 --- a/compiler/GHC/Tc/Gen/Bind.hs +++ b/compiler/GHC/Tc/Gen/Bind.hs @@ -632,7 +632,7 @@ tcPolyCheck prag_fn (mkCheckExpType rho_ty) -- We make a funny AbsBinds, abstracting over nothing, - -- just so we haev somewhere to put the SpecPrags. + -- just so we have somewhere to put the SpecPrags. -- Otherwise we could just use the FunBind -- Hence poly_id2 is just a clone of poly_id; -- We re-use mono-name, but we could equally well use a fresh one diff --git a/compiler/GHC/Tc/Gen/HsType.hs b/compiler/GHC/Tc/Gen/HsType.hs index 698f81185d..87da41b890 100644 --- a/compiler/GHC/Tc/Gen/HsType.hs +++ b/compiler/GHC/Tc/Gen/HsType.hs @@ -473,7 +473,7 @@ tc_lhs_sig_type skol_info (L loc (HsSig { sig_bndrs = hs_outer_bndrs ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ tcHsSigType is tricky. Consider (T11142) foo :: forall b. (forall k (a :: k). SameKind a b) -> () -This is ill-kinded becuase of a nested skolem-escape. +This is ill-kinded because of a nested skolem-escape. That will show up as an un-solvable constraint in the implication returned by buildTvImplication in tc_lhs_sig_type. See Note [Skolem @@ -3249,7 +3249,7 @@ bindImplicitTKBndrsX skol_mode@(SM { sm_parent = check_parent, sm_kind = ctxt_ki -- SkolemMode -------------------------------------- --- | 'SkolemMode' decribes how to typecheck an explicit ('HsTyVarBndr') or +-- | 'SkolemMode' describes how to typecheck an explicit ('HsTyVarBndr') or -- implicit ('Name') binder in a type. It is just a record of flags -- that describe what sort of 'TcTyVar' to create. data SkolemMode @@ -3430,7 +3430,7 @@ filterConstrainedCandidates wanted dvs ; _ <- promoteTyVarSet to_promote ; return dvs' } --- |- Specialised verison of 'kindGeneralizeSome', but with empty +-- |- Specialised version of 'kindGeneralizeSome', but with empty -- WantedConstraints, so no filtering is needed -- i.e. kindGeneraliseAll = kindGeneralizeSome emptyWC kindGeneralizeAll :: TcType -> TcM [KindVar] @@ -3440,7 +3440,7 @@ kindGeneralizeAll kind_or_type ; quantifyTyVars dvs } -- | Specialized version of 'kindGeneralizeSome', but where no variables --- can be generalized, but perhaps some may neeed to be promoted. +-- can be generalized, but perhaps some may need to be promoted. -- Use this variant when it is unknowable whether metavariables might -- later be constrained. -- @@ -3911,7 +3911,7 @@ We achieve this as follows: - For /named/ wildcards such sas g :: forall b. (forall la. a -> _x) -> b there is no problem: we create them at the outer level (ie the - ambient level of teh signature itself), and push the level when we + ambient level of the signature itself), and push the level when we go inside a forall. So now the unification variable for the "_x" can't unify with skolem 'a'. diff --git a/compiler/GHC/Tc/Gen/Pat.hs b/compiler/GHC/Tc/Gen/Pat.hs index 442d287ed8..837fb7fbdc 100644 --- a/compiler/GHC/Tc/Gen/Pat.hs +++ b/compiler/GHC/Tc/Gen/Pat.hs @@ -458,7 +458,7 @@ Consider this exotic example: f :: Int -> blah f (pair True -> x) = ...here (x :: forall b. b -> (Int,b)) -The expresion (pair True) should have type +The expression (pair True) should have type pair True :: Int -> forall b. b -> (Int,b) so that it is ready to consume the incoming Int. It should be an arrow type (t1 -> t2); hence using (tcInferRho expr). diff --git a/compiler/GHC/Tc/Solver.hs b/compiler/GHC/Tc/Solver.hs index 7e1f919e1f..697cea0f47 100644 --- a/compiler/GHC/Tc/Solver.hs +++ b/compiler/GHC/Tc/Solver.hs @@ -223,7 +223,7 @@ simplifyAndEmitFlatConstraints wanted ; tclvl <- TcM.getTcLevel ; implic <- buildTvImplication UnkSkol [] tclvl wanted -- UnkSkol: doesn't matter, because - -- we bind no skolem varaibles here + -- we bind no skolem variables here ; emitImplication implic ; failM } Just (simples, holes) @@ -312,7 +312,7 @@ should be well. BUT it's hard to see that when kind-checking the signature for undefined. We want to emit a residual (a~b) constraint, to solve later. -Another possiblity is that we might have something like +Another possibility is that we might have something like F alpha ~ [Int] where alpha is bound further out, which might become soluble "later" when we learn more about alpha. So we want to emit diff --git a/compiler/GHC/Tc/Solver/Interact.hs b/compiler/GHC/Tc/Solver/Interact.hs index b1eb5bd712..00ee528fdc 100644 --- a/compiler/GHC/Tc/Solver/Interact.hs +++ b/compiler/GHC/Tc/Solver/Interact.hs @@ -1577,7 +1577,7 @@ by unification, there are two cases to consider alpha[n] is at level n, and so if we set, say, alpha[n] := Maybe beta[m], we must ensure that when unifying beta we do skolem-escape checks - etc relevent to level n. Simple way to do that: promote beta to + etc relevant to level n. Simple way to do that: promote beta to level n. 2. Set the Unification Level Flag to record that a level-n unification has @@ -1586,7 +1586,7 @@ by unification, there are two cases to consider NB: UnifySameLevel is just an optimisation for UnifyOuterLevel. Promotion would be a no-op, and setting the unification flag unnecessarily would just make the solver iterate more often. (We don't need to iterate when unifying -at the ambient level becuase of the kick-out mechanism.) +at the ambient level because of the kick-out mechanism.) ************************************************************************ diff --git a/compiler/GHC/Tc/Solver/Monad.hs b/compiler/GHC/Tc/Solver/Monad.hs index c5e9c343ae..4c16f2f56e 100644 --- a/compiler/GHC/Tc/Solver/Monad.hs +++ b/compiler/GHC/Tc/Solver/Monad.hs @@ -2040,7 +2040,7 @@ NB: we could in principle avoid kick-out: b) For Givens, after a unification. By (GivenInv) in GHC.Tc.Utils.TcType Note [TcLevel invariants], a Given can't include a meta-tyvar from its own level, so it falls under (a). Of course, we must still - kick out Givens when adding a new non-unificaiton Given. + kick out Givens when adding a new non-unification Given. But kicking out more vigorously may lead to earlier unification and fewer iterations, so we don't take advantage of these possibilities. @@ -3438,7 +3438,7 @@ Answer: if any unification of a tyvar at level n takes place * What if a unification takes place at level n, in the ic_simples of level n? No need to track this, because the kick-out mechanism deals - with it. (We can't drop kick-out in favour of iteration, becuase kick-out + with it. (We can't drop kick-out in favour of iteration, because kick-out works for skolem-equalities, not just unifications.) So the monad-global Unification Level Flag, kept in tcs_unif_lvl keeps diff --git a/compiler/GHC/Tc/TyCl.hs b/compiler/GHC/Tc/TyCl.hs index d434331605..6f7a7c548c 100644 --- a/compiler/GHC/Tc/TyCl.hs +++ b/compiler/GHC/Tc/TyCl.hs @@ -779,7 +779,7 @@ swizzleTcTyConBndrs tc_infos | (tc, scoped_prs, kind) <- tc_infos ] swizzle_prs :: [(Name,TyVar)] - -- Pairs the user-specifed Name with its representative TyVar + -- Pairs the user-specified Name with its representative TyVar -- See Note [Swizzling the tyvars before generaliseTcTyCon] swizzle_prs = [ pr | (_, prs, _) <- tc_infos, pr <- prs ] diff --git a/compiler/GHC/Tc/TyCl/Instance.hs b/compiler/GHC/Tc/TyCl/Instance.hs index 8bc1d3a746..469ef20778 100644 --- a/compiler/GHC/Tc/TyCl/Instance.hs +++ b/compiler/GHC/Tc/TyCl/Instance.hs @@ -1112,7 +1112,7 @@ the /data constructor/ declarations altogether, looking only at the data instance /header/. Observations: -* This choice is simple to describe, as well as simple to implment. +* This choice is simple to describe, as well as simple to implement. For a data/newtype instance decl, the instance kinds are influenced /only/ by the header. diff --git a/compiler/GHC/Tc/TyCl/Utils.hs b/compiler/GHC/Tc/TyCl/Utils.hs index b9fb54cc9f..2135f18b77 100644 --- a/compiler/GHC/Tc/TyCl/Utils.hs +++ b/compiler/GHC/Tc/TyCl/Utils.hs @@ -1105,6 +1105,6 @@ We want to generate HsBinds for unT that look something like this: Note that the type of recSelError is `forall r (a :: TYPE r). Addr# -> a`. Therefore, when used in the right-hand side of `unT`, GHC attempts to instantiate `a` with `(forall b. b -> b) -> Int`, which is impredicative. -To make sure that GHC is OK with this, we enable ImpredicativeTypes interally +To make sure that GHC is OK with this, we enable ImpredicativeTypes internally when typechecking these HsBinds so that the user does not have to. -} diff --git a/compiler/GHC/Tc/Utils/Unify.hs b/compiler/GHC/Tc/Utils/Unify.hs index 23dcfe6e83..121ebfbe7e 100644 --- a/compiler/GHC/Tc/Utils/Unify.hs +++ b/compiler/GHC/Tc/Utils/Unify.hs @@ -176,7 +176,7 @@ before looking for an arrow type. But if it doesn't find an arrow type, it wants to generate a message like "f is applied to two arguments but its type only has one". -To do that, it needs to konw about the args that tcArgs has already +To do that, it needs to know about the args that tcArgs has already munched up -- hence passing in n_val_args_in_call and arg_tys_so_far; and hence also the accumulating so_far arg to 'go'. diff --git a/compiler/GHC/Tc/Utils/Zonk.hs b/compiler/GHC/Tc/Utils/Zonk.hs index 76b101c679..4fb5286c70 100644 --- a/compiler/GHC/Tc/Utils/Zonk.hs +++ b/compiler/GHC/Tc/Utils/Zonk.hs @@ -1777,7 +1777,7 @@ Solution: (see #15552 for other variants) the treatment of lexically-scoped variables in ze_tv_env and ze_id_env.) - Is the extra work worth it? Some non-sytematic perf measurements + Is the extra work worth it? Some non-systematic perf measurements suggest that compiler allocation is reduced overall (by 0.5% or so) but compile time really doesn't change. -} diff --git a/compiler/GHC/Types/Basic.hs b/compiler/GHC/Types/Basic.hs index 3b2f1a3140..4c92b8f9a3 100644 --- a/compiler/GHC/Types/Basic.hs +++ b/compiler/GHC/Types/Basic.hs @@ -938,7 +938,7 @@ type RulesOnly = Bool type BranchCount = Int -- For OneOcc, the BranchCount says how many syntactic occurrences there are -- At the moment we really only check for 1 or >1, but in principle - -- we could pay attention to how *many* occurences there are + -- we could pay attention to how *many* occurrences there are -- (notably in postInlineUnconditionally). -- But meanwhile, Ints are very efficiently represented. diff --git a/compiler/GHC/Types/Demand.hs b/compiler/GHC/Types/Demand.hs index c2e4770da6..0a23e10224 100644 --- a/compiler/GHC/Types/Demand.hs +++ b/compiler/GHC/Types/Demand.hs @@ -1300,7 +1300,7 @@ But the demand fed into f might be less than CS(CS(U)). Then we have to - We have to multiply divergence with C_01. If r says that f Diverges for sure, then this holds when the demand guarantees that two arguments are going to be passed. If the demand is lower, we may just as well converge. - If we were tracking definite convegence, than that would still hold under + If we were tracking definite convergence, than that would still hold under a weaker demand than expected by the demand transformer. * Used more than once, e.g. CM(CS(U)): - Multiply with C_1N. Even if f puts a used-once demand on any of its argument diff --git a/compiler/GHC/Types/Name/Occurrence.hs b/compiler/GHC/Types/Name/Occurrence.hs index d2e4127010..d29d7ab7ec 100644 --- a/compiler/GHC/Types/Name/Occurrence.hs +++ b/compiler/GHC/Types/Name/Occurrence.hs @@ -646,7 +646,7 @@ mkNewTyCoOcc = mk_simple_deriv tcName "N:" -- Coercion for newtypes mkInstTyCoOcc = mk_simple_deriv tcName "D:" -- Coercion for type functions mkEqPredCoOcc = mk_simple_deriv tcName "$co" --- Used in derived instances for the names of auxilary bindings. +-- Used in derived instances for the names of auxiliary bindings. -- See Note [Auxiliary binders] in GHC.Tc.Deriv.Generate. mkCon2TagOcc = mk_simple_deriv varName "$con2tag_" mkTag2ConOcc = mk_simple_deriv varName "$tag2con_" diff --git a/compiler/GHC/Utils/Misc.hs b/compiler/GHC/Utils/Misc.hs index d0989de39e..46fb352e61 100644 --- a/compiler/GHC/Utils/Misc.hs +++ b/compiler/GHC/Utils/Misc.hs @@ -785,7 +785,7 @@ splitAtList xs ys = go 0# xs ys -- drop from the end of a list dropTail :: Int -> [a] -> [a] -- Specification: dropTail n = reverse . drop n . reverse --- Better implemention due to Joachim Breitner +-- Better implementation due to Joachim Breitner -- http://www.joachim-breitner.de/blog/archives/600-On-taking-the-last-n-elements-of-a-list.html dropTail n xs = go (drop n xs) xs diff --git a/compiler/Language/Haskell/Syntax/Decls.hs b/compiler/Language/Haskell/Syntax/Decls.hs index ff65d085c7..453b963028 100644 --- a/compiler/Language/Haskell/Syntax/Decls.hs +++ b/compiler/Language/Haskell/Syntax/Decls.hs @@ -950,7 +950,7 @@ type LDerivClauseTys pass = XRec pass (DerivClauseTys pass) -- | The types mentioned in a single @deriving@ clause. This can come in two -- forms, 'DctSingle' or 'DctMulti', depending on whether the types are -- surrounded by enclosing parentheses or not. These parentheses are --- semantically differnt than 'HsParTy'. For example, @deriving ()@ means +-- semantically different than 'HsParTy'. For example, @deriving ()@ means -- \"derive zero classes\" rather than \"derive an instance of the 0-tuple\". -- -- 'DerivClauseTys' use 'LHsSigType' because @deriving@ clauses can mention diff --git a/compiler/Language/Haskell/Syntax/Expr.hs b/compiler/Language/Haskell/Syntax/Expr.hs index 72c16fe22a..0e54adb8f4 100644 --- a/compiler/Language/Haskell/Syntax/Expr.hs +++ b/compiler/Language/Haskell/Syntax/Expr.hs @@ -1267,7 +1267,7 @@ data ParStmtBlock idL idR -- | The fail operator -- --- This is used for `.. <-` "bind statments" in do notation, including +-- This is used for `.. <-` "bind statements" in do notation, including -- non-monadic "binds" in applicative. -- -- The fail operator is 'Just expr' if it potentially fail monadically. if the diff --git a/docs/users_guide/9.0.1-notes.rst b/docs/users_guide/9.0.1-notes.rst index 4b6ae89290..46c847191a 100644 --- a/docs/users_guide/9.0.1-notes.rst +++ b/docs/users_guide/9.0.1-notes.rst @@ -40,7 +40,7 @@ Highlights GHC is now able to detect the case alt returning 3 as redundant. - Some more performance improvements in edge cases. -* Windows: Use the larg address space allocator. +* Windows: Use the large address space allocator. This improves runtime but causes increased memory usage on Windows versions older than Win 8.1/Server 2012. diff --git a/docs/users_guide/9.2.1-notes.rst b/docs/users_guide/9.2.1-notes.rst index a51875d3f4..96306e4d9c 100644 --- a/docs/users_guide/9.2.1-notes.rst +++ b/docs/users_guide/9.2.1-notes.rst @@ -98,7 +98,7 @@ Runtime system - The :rts-flag:`-h` flag has been deprecated, use either :rts-flag:`-hc` or - :rts-flag:`-hT` explicitly, as appropiate. + :rts-flag:`-hT` explicitly, as appropriate. ``ghc-prim`` library ~~~~~~~~~~~~~~~~~~~~ @@ -163,7 +163,7 @@ Runtime system ``Natural``. As a consequence, one must enable ``TypeSynonymInstances`` in order to define instances for ``Nat``. - The ``Numeric`` module recieves ``showBin`` and ``readBin`` to show and + The ``Numeric`` module receives ``showBin`` and ``readBin`` to show and read integer numbers in binary. - ``Char`` gets type-level support by analogy with strings and natural numbers. diff --git a/docs/users_guide/phases.rst b/docs/users_guide/phases.rst index 797b10e8fe..73d9777f99 100644 --- a/docs/users_guide/phases.rst +++ b/docs/users_guide/phases.rst @@ -190,7 +190,7 @@ the following flags: specified compiler will support it. This flag can be used to indicate that ``-no-pie`` is supported. It has to be passed after ``-pgmc``. - This flag is not neccessary when ``-pgmc`` is not used, since GHC + This flag is not necessary when ``-pgmc`` is not used, since GHC remembers whether the default C compiler supports ``-no-pie`` in an internal settings file. diff --git a/docs/users_guide/using-optimisation.rst b/docs/users_guide/using-optimisation.rst index ee5b1de95e..a53fa21802 100644 --- a/docs/users_guide/using-optimisation.rst +++ b/docs/users_guide/using-optimisation.rst @@ -1147,8 +1147,8 @@ by saying ``-fno-wombat``. dummy value at the call site or omitted altogether. The worker/wrapper transformation (:ghc-flag:`-fworker-wrapper`) is - reponsible for exploiting unboxing opportunities and replacing absent - arguments by dummies. For arugments that can't be unboxed, opportunities + responsible for exploiting unboxing opportunities and replacing absent + arguments by dummies. For arguments that can't be unboxed, opportunities for call-by-value and call-by-name are exploited in CorePrep when translating to STG. diff --git a/ghc/GHCi/UI.hs b/ghc/GHCi/UI.hs index 77801019ee..48886ea88f 100644 --- a/ghc/GHCi/UI.hs +++ b/ghc/GHCi/UI.hs @@ -1838,7 +1838,7 @@ buildDocComponents str name = do pure DocComponents{..} --- | Produce output containing the type/kind signature, category, and definiton +-- | Produce output containing the type/kind signature, category, and definition -- location of a TyThing. sigAndLocDoc :: String -> TyThing -> SDoc sigAndLocDoc str tyThing = diff --git a/hadrian/src/Rules/Compile.hs b/hadrian/src/Rules/Compile.hs index 0efcea9474..b21bcaf74b 100644 --- a/hadrian/src/Rules/Compile.hs +++ b/hadrian/src/Rules/Compile.hs @@ -69,7 +69,7 @@ compilePackage rs = do -- or if some of the dynamic artifacts have been removed by the -- user, "needing" the non dynamic artifacts is not enough as -- Shake won't execute the associated action. Hence we detect - -- this case and we explictly build the dynamic artifacts here: + -- this case and we explicitly build the dynamic artifacts here: case changed of [] -> compileHsObjectAndHi rs dyn_o _ -> pure () diff --git a/includes/rts/FileLock.h b/includes/rts/FileLock.h index 69df911595..3d8056d7a0 100644 --- a/includes/rts/FileLock.h +++ b/includes/rts/FileLock.h @@ -21,7 +21,7 @@ * Instead we keep track of locked files in a data structure in * the RTS. This file provides the interface to this data structure. * - * In the base librarie we then use this interface to "lock" files. + * In the base libraries we then use this interface to "lock" files. * This means it's very much still possible for users outside of the * rts/base library to open the files in question even if they are * locked. diff --git a/libraries/base/Data/Traversable.hs b/libraries/base/Data/Traversable.hs index d18b0ed98d..3c27c6e77e 100644 --- a/libraries/base/Data/Traversable.hs +++ b/libraries/base/Data/Traversable.hs @@ -604,7 +604,7 @@ foldMapDefault = coerce (traverse :: (a -> Const m ()) -> t a -> Const m (t ())) -- Left ("That's odd",9) -- -- The 'Foldable' instance should be defined in a manner that avoids --- construction of an unnecesary copy of the container. +-- construction of an unnecessary copy of the container. -- -- The @Foldable@ method 'mapM_' and its flipped version 'forM_' can be used -- to sequence IO actions over all the elements of a @Traversable@ container diff --git a/libraries/base/GHC/Event/Windows.hsc b/libraries/base/GHC/Event/Windows.hsc index ea2c51053a..d9a107bbd0 100644 --- a/libraries/base/GHC/Event/Windows.hsc +++ b/libraries/base/GHC/Event/Windows.hsc @@ -564,7 +564,7 @@ withOverlappedEx mgr fname h offset startCB completionCB = do -- relied on for non-file handles we need a way to prevent -- us from handling a request inline and handle a completion -- event handled without a queued I/O operation. Which means we - -- can't solely rely on the number of oustanding requests but most + -- can't solely rely on the number of outstanding requests but most -- also check intermediate status. reqs <- addRequest debugIO $ "+1.. " ++ show reqs ++ " requests queued. | " ++ show lpol diff --git a/libraries/base/GHC/ForeignPtr.hs b/libraries/base/GHC/ForeignPtr.hs index 718b5a8749..a64d4d19c6 100644 --- a/libraries/base/GHC/ForeignPtr.hs +++ b/libraries/base/GHC/ForeignPtr.hs @@ -134,7 +134,7 @@ data ForeignPtrContents -- reachable (by GC) whenever the 'ForeignPtr' is reachable. When the -- 'ForeignPtr' becomes unreachable, the runtime\'s normal GC recovers -- the memory backing it. Here, the finalizer function intended to be used - -- to @free()@ any ancilliary *unmanaged* memory pointed to by the + -- to @free()@ any ancillary *unmanaged* memory pointed to by the -- 'MutableByteArray#'. See the @zlib@ library for an example of this use. -- -- 1. Invariant: The 'Addr#' in the parent 'ForeignPtr' is an interior diff --git a/libraries/base/GHC/IO/Windows/Encoding.hs b/libraries/base/GHC/IO/Windows/Encoding.hs index c0ee649662..d86487bc5f 100644 --- a/libraries/base/GHC/IO/Windows/Encoding.hs +++ b/libraries/base/GHC/IO/Windows/Encoding.hs @@ -9,7 +9,7 @@ Stability : Provisional Portability : Non-portable (Win32 API) - Enocode/Decode mutibyte charactor using Win32 API. + Enocode/Decode mutibyte character using Win32 API. -} module GHC.IO.Windows.Encoding diff --git a/libraries/base/GHC/IO/Windows/Handle.hsc b/libraries/base/GHC/IO/Windows/Handle.hsc index ba7f4d1488..9a28b0dda2 100644 --- a/libraries/base/GHC/IO/Windows/Handle.hsc +++ b/libraries/base/GHC/IO/Windows/Handle.hsc @@ -884,7 +884,7 @@ openFile' filepath iomode non_blocking tmp_opts = -- on the Haskell side by using existing mechanisms such as MVar -- or IOPorts. then #{const FILE_FLAG_OVERLAPPED} - -- I beleive most haskell programs do sequential scans, so + -- I believe most haskell programs do sequential scans, so -- optimize for the common case. Though ideally, this would -- be parameterized by openFile. This will absolutely trash -- the cache on reverse scans. diff --git a/libraries/base/Unsafe/Coerce.hs b/libraries/base/Unsafe/Coerce.hs index 6792592254..7c8e39e92e 100644 --- a/libraries/base/Unsafe/Coerce.hs +++ b/libraries/base/Unsafe/Coerce.hs @@ -132,7 +132,7 @@ several ways x = K a in ... Flaoting the case is OK here, even though it broardens the - scope, becuase we are done with simplification. + scope, because we are done with simplification. (U4) GHC.CoreToStg.Prep.cpeExprIsTrivial anticipates the upcoming discard of unsafeEqualityProof. @@ -220,7 +220,7 @@ There are yet more wrinkles GHCi debugger, and GHCi itself uses unsafeCoerce. Moreover, in GHC.Tc.Module.tcGhciStmts we use unsafeCoerce#, rather - than the more kosher unsafeCoerce, becuase (with -O0) the latter + than the more kosher unsafeCoerce, because (with -O0) the latter may not be inlined. Sigh diff --git a/libraries/base/tests/perf/Makefile b/libraries/base/tests/perf/Makefile index 28840dc0b9..8ffa651a33 100644 --- a/libraries/base/tests/perf/Makefile +++ b/libraries/base/tests/perf/Makefile @@ -9,7 +9,7 @@ include $(TOP)/mk/test.mk T17752: '$(TEST_HC)' $(TEST_HC_OPTS) -O --make T17752 -rtsopts -ddump-simpl -ddump-to-file -dsuppress-uniques -dsuppress-all - # All occurences of elem should be optimized away. + # All occurrences of elem should be optimized away. # For strings these should result in loops after inlining foldCString. # For lists it should result in a case expression. echo $$(cat T17752.dump-simpl | grep "elem" -A4 ) diff --git a/libraries/base/tests/perf/T17752.hs b/libraries/base/tests/perf/T17752.hs index f7f136e1f4..3c4565ec9c 100644 --- a/libraries/base/tests/perf/T17752.hs +++ b/libraries/base/tests/perf/T17752.hs @@ -1,6 +1,6 @@ module T17752 where --- All occurences of elem should be optimized away. +-- All occurrences of elem should be optimized away. -- For strings these should result in loops after inlining foldCString. -- For lists it should result in a case expression. diff --git a/libraries/ghc-bignum/src/GHC/Num/Integer.hs b/libraries/ghc-bignum/src/GHC/Num/Integer.hs index 35afa5d15a..ae0d6af20b 100644 --- a/libraries/ghc-bignum/src/GHC/Num/Integer.hs +++ b/libraries/ghc-bignum/src/GHC/Num/Integer.hs @@ -577,7 +577,7 @@ integerTestBit# (IN x) i | isTrue# (iw >=# n) = 1# -- if all the limbs j with j < iw are null, then we have to consider the - -- carry of the 2's complement convertion. Otherwise we just have to return + -- carry of the 2's complement conversion. Otherwise we just have to return -- the inverse of the bit test | allZ iw = testBitW# (xi `minusWord#` 1##) ib ==# 0# | True = testBitW# xi ib ==# 0# diff --git a/rts/HeapStackCheck.cmm b/rts/HeapStackCheck.cmm index b8df323c8b..ba89f75522 100644 --- a/rts/HeapStackCheck.cmm +++ b/rts/HeapStackCheck.cmm @@ -524,7 +524,7 @@ stg_block_takemvar_finally jump StgReturn [R1]; } -// Stack useage covered by RESERVED_STACK_WORDS +// Stack usage covered by RESERVED_STACK_WORDS stg_block_takemvar /* mvar passed in R1 */ { Sp_adj(-2); diff --git a/rts/RtsAPI.c b/rts/RtsAPI.c index 3f18a5bc02..d334a05dfb 100644 --- a/rts/RtsAPI.c +++ b/rts/RtsAPI.c @@ -720,7 +720,7 @@ PauseToken *rts_pause (void) Task * task = getMyTask(); if (rts_pausing_task == task) { - // This task already pased the RTS. + // This task already passed the RTS. errorBelch("error: rts_pause: This thread has already paused the RTS."); stg_exit(EXIT_FAILURE); } @@ -799,7 +799,7 @@ static void assert_isPausedOnMyTask(const char *functionName) if (task != rts_pausing_task) { // We don't have ownership of rts_pausing_task, so it may have changed - // just after the above read. Still, we are garanteed that + // just after the above read. Still, we are guaranteed that // rts_pausing_task won't be set to the current task (because the // current task is here now!), so the error messages are still correct. errorBelch ( diff --git a/rts/RtsFlags.c b/rts/RtsFlags.c index ddd561b29c..380ccc3afc 100644 --- a/rts/RtsFlags.c +++ b/rts/RtsFlags.c @@ -502,7 +502,7 @@ usage_text[] = { #if defined(mingw32_HOST_OS) " --io-manager-threads=<num>", " The number of worker threads to use in the native I/O manager to", -" handle completion events. (defualt: num cores)", +" handle completion events. (default: num cores)", #endif " -e<n> Maximum number of outstanding local sparks (default: 4096)", #endif diff --git a/rts/Stats.c b/rts/Stats.c index 53251bb7d6..2770696b66 100644 --- a/rts/Stats.c +++ b/rts/Stats.c @@ -1595,7 +1595,7 @@ Parallel garbage collector counters: * scav_find_work: Counts iterations of scavenge loop * max_n_todo_overflow: - Tracks the maximum length of todo_overflow lists in the gc_thread structre. + Tracks the maximum length of todo_overflow lists in the gc_thread structure. See comment in grab_local_todo_block. */ diff --git a/rts/sm/GC.c b/rts/sm/GC.c index 0f9a9eaa84..6d222da02a 100644 --- a/rts/sm/GC.c +++ b/rts/sm/GC.c @@ -1412,7 +1412,7 @@ waitForGcThreads (Capability *cap, bool idle_cap[]) } } - ASSERT(n_threads < n_capabilities); // must be less becasue we don't count ourself + ASSERT(n_threads < n_capabilities); // must be less because we don't count ourself if(n_threads == 0) { return; } ACQUIRE_LOCK(&gc_entry_mutex); diff --git a/rts/win32/AsyncWinIO.c b/rts/win32/AsyncWinIO.c index 0c0b45e60f..7fb71e92e7 100644 --- a/rts/win32/AsyncWinIO.c +++ b/rts/win32/AsyncWinIO.c @@ -149,7 +149,7 @@ * call ioManagerStart() * Creat a thread to execute "runner" - We never truely shut down the IO Manager. While this means we + We never truly shut down the IO Manager. While this means we might block forever on the IOPort if the IO Manager is no longer needed we consider this cheap compared to the complexity of properly handling pausing and resuming of the manager. @@ -284,7 +284,7 @@ void shutdownAsyncWinIO(bool wait_threads) ioManagerDie (); } -/* Register the I/O completetion port handle PORT that the I/O manager will be +/* Register the I/O completion port handle PORT that the I/O manager will be monitoring. All handles are expected to be associated with this handle. */ void registerIOCPHandle (HANDLE port) { @@ -365,7 +365,7 @@ void registerAlertableWait (bool has_timeout, DWORD mssec) ReleaseSRWLockExclusive (&wio_runner_lock); /* Since we call registerAlertableWait only after - processing I/O requests it's always desireable to wake + processing I/O requests it's always desirable to wake up the runner here. */ WakeConditionVariable (&wakeEvent); diff --git a/testsuite/driver/perf_notes.py b/testsuite/driver/perf_notes.py index eb31f463da..a320f22336 100644 --- a/testsuite/driver/perf_notes.py +++ b/testsuite/driver/perf_notes.py @@ -487,7 +487,7 @@ def get_commit_metric_value_str_or_none(gitNoteRef, return str(result.value) # gets the average commit metric from git notes. -# gitNoteRef: git notes ref sapce e.g. "perf" or "ci/perf" +# gitNoteRef: git notes ref space e.g. "perf" or "ci/perf" # ref: git commit # test_env: test environment # name: test name diff --git a/testsuite/driver/testglobals.py b/testsuite/driver/testglobals.py index 5826a976e1..2b3dd48b68 100644 --- a/testsuite/driver/testglobals.py +++ b/testsuite/driver/testglobals.py @@ -169,7 +169,7 @@ class TestConfig: # run. self.broken_tests = set() # type: Set[TestName] - # Baseline commit for performane metric comparisons. + # Baseline commit for performance metric comparisons. self.baseline_commit = None # type: Optional[GitRef] # Additional package dbs to inspect for test dependencies. diff --git a/testsuite/tests/codeGen/should_run/cgrun069_cmm.cmm b/testsuite/tests/codeGen/should_run/cgrun069_cmm.cmm index 006595e319..989251d646 100644 --- a/testsuite/tests/codeGen/should_run/cgrun069_cmm.cmm +++ b/testsuite/tests/codeGen/should_run/cgrun069_cmm.cmm @@ -139,7 +139,7 @@ loop_end: \ foreign "C" free(dst); \ return (0); -// This is not exactly beutiful but we need the separate functions to +// This is not exactly beautiful but we need the separate functions to // avoid collisions between labels. // // The specific tests are selected with knowledge of the implementation diff --git a/testsuite/tests/dynlibs/all.T b/testsuite/tests/dynlibs/all.T index 092c983389..79d4ee9c5a 100644 --- a/testsuite/tests/dynlibs/all.T +++ b/testsuite/tests/dynlibs/all.T @@ -20,5 +20,5 @@ test('T18072', [req_shared_libs, unless(opsys('linux'), skip)], makefile_test, [ # test that -shared and -flink-rts respects alternative RTS flavours test('T18072debug', [extra_files(['T18072.hs']), req_shared_libs, unless(opsys('linux'), skip)], makefile_test, []) -# check that -staticlib and -fno-link-rts results in an archive without the RTR libary +# check that -staticlib and -fno-link-rts results in an archive without the RTR library test('T18072static', [extra_files(['T18072.hs']), unless(opsys('linux'), skip)], makefile_test, []) diff --git a/testsuite/tests/gadt/SynDataRec.hs b/testsuite/tests/gadt/SynDataRec.hs index 021ed0ba17..fe290a8cae 100644 --- a/testsuite/tests/gadt/SynDataRec.hs +++ b/testsuite/tests/gadt/SynDataRec.hs @@ -2,7 +2,7 @@ module SynDataRec where --- This mutual recursion betwen a data type and +-- This mutual recursion between a data type and -- a type synonym is a little delicate. See -- Note [GADT return types] in GHC.Tc.TyCl diff --git a/testsuite/tests/hiefile/should_compile/Scopes.hs b/testsuite/tests/hiefile/should_compile/Scopes.hs index 21766c6446..a6714a9a68 100644 --- a/testsuite/tests/hiefile/should_compile/Scopes.hs +++ b/testsuite/tests/hiefile/should_compile/Scopes.hs @@ -6,7 +6,7 @@ module Scopes where --- Verify that evidence bound by patern +-- Verify that evidence bound by pattern -- synonyms has correct scope pattern LL :: Num a => a -> a pattern LL x <- (subtract 1 -> x) @@ -19,7 +19,7 @@ data T = C { x :: Int, y :: Char } -- have correct scope foo = C { x = 1 , y = 'a' } --- Verify that implicit paramters have correct scope +-- Verify that implicit parameters have correct scope bar :: (?x :: Int) => Int bar = ?x + 1 diff --git a/testsuite/tests/indexed-types/should_compile/T18809.hs b/testsuite/tests/indexed-types/should_compile/T18809.hs index 1e56d980f6..0135c4e370 100644 --- a/testsuite/tests/indexed-types/should_compile/T18809.hs +++ b/testsuite/tests/indexed-types/should_compile/T18809.hs @@ -16,7 +16,7 @@ data F1 s where bar1 :: F1 s -> Int -> F1 s bar1 z y = z { foo1 = y } --- Orinary data family +-- Ordinary data family data family F3 a data instance F3 (s,t) where MkF2b :: { foo3 :: Int } -> F3 (s,t) diff --git a/testsuite/tests/linear/should_compile/CSETest.hs b/testsuite/tests/linear/should_compile/CSETest.hs index 3321dbd43d..71f807dc26 100644 --- a/testsuite/tests/linear/should_compile/CSETest.hs +++ b/testsuite/tests/linear/should_compile/CSETest.hs @@ -2,7 +2,7 @@ {-# LANGUAGE NoImplicitPrelude #-} {-# LANGUAGE UnicodeSyntax #-} {- This test makes sure that if two expressions with conflicting types are - CSEd then appropiate things happen. -} + CSEd then appropriate things happen. -} module CSETest where minimal :: a ⊸ a diff --git a/testsuite/tests/pmcheck/should_compile/T17340.hs b/testsuite/tests/pmcheck/should_compile/T17340.hs index fa2ef60812..b3d69b4da2 100644 --- a/testsuite/tests/pmcheck/should_compile/T17340.hs +++ b/testsuite/tests/pmcheck/should_compile/T17340.hs @@ -51,4 +51,4 @@ w _ _ = () z :: T2 a -> Bool -> () z _ True = () z t2 !x | T2 _ <- t2, x = () -- redundant - | !_ <- t2, x = () -- inaccessable + | !_ <- t2, x = () -- inaccessible diff --git a/testsuite/tests/pmcheck/should_compile/T18478.hs b/testsuite/tests/pmcheck/should_compile/T18478.hs index 372ac2d171..6739388d99 100644 --- a/testsuite/tests/pmcheck/should_compile/T18478.hs +++ b/testsuite/tests/pmcheck/should_compile/T18478.hs @@ -530,7 +530,7 @@ forbiddenOpEvi = Sub $ OpAbsent -> Dict OpPresent -> error "impossible" --- | Reify 'HasNoOp' contraint from 'ForbidOp'. +-- | Reify 'HasNoOp' constraint from 'ForbidOp'. -- -- Left for backward compatibility. forbiddenOp @@ -566,7 +566,7 @@ forbiddenNestedBigMaps -> a forbiddenNestedBigMaps = withDict $ forbiddenNestedBigMapsEvi @t --- | Reify 'HasNoContract' contraint from 'ForbidContract'. +-- | Reify 'HasNoContract' constraint from 'ForbidContract'. forbiddenContractTypeEvi :: forall t. (SingI t, ForbidContract t) :- HasNoContract t forbiddenContractTypeEvi = Sub $ @@ -574,7 +574,7 @@ forbiddenContractTypeEvi = Sub $ ContractAbsent -> Dict ContractPresent -> error "impossible" --- | Reify 'HasNoContract' contraint from 'ForbidContract'. +-- | Reify 'HasNoContract' constraint from 'ForbidContract'. forbiddenContractType :: forall t a. (SingI t, ForbidContract t) diff --git a/testsuite/tests/stranal/should_run/T13380d.hs b/testsuite/tests/stranal/should_run/T13380d.hs index 440c4ced1e..3430c958c0 100644 --- a/testsuite/tests/stranal/should_run/T13380d.hs +++ b/testsuite/tests/stranal/should_run/T13380d.hs @@ -5,7 +5,7 @@ import Control.Exception import GHC.Exts import GHC.IO --- | An "unboxed" IO action that throws a precise excpetion that isn't inlined. +-- | An "unboxed" IO action that throws a precise exception that isn't inlined. throws :: State# RealWorld -> State# RealWorld throws s = case raiseIO# (toException (userError "What")) s of (# s', _ #) -> s' {-# NOINLINE throws #-} diff --git a/testsuite/tests/stranal/should_run/T13380e.hs b/testsuite/tests/stranal/should_run/T13380e.hs index d807db091b..b69dfd51e9 100644 --- a/testsuite/tests/stranal/should_run/T13380e.hs +++ b/testsuite/tests/stranal/should_run/T13380e.hs @@ -3,7 +3,7 @@ import Control.Exception -- This is just like T13380d, but doesn't look through the IO abstraction. -- With Nested CPR, it will result in very similar code, however! --- | An IO action that throws a precise excpetion that isn't inlined. +-- | An IO action that throws a precise exception that isn't inlined. throws :: IO () throws = throwIO (userError "What") {-# NOINLINE throws #-} diff --git a/testsuite/tests/stranal/sigs/T18086.hs b/testsuite/tests/stranal/sigs/T18086.hs index 639409adce..9a6f67c6d1 100644 --- a/testsuite/tests/stranal/sigs/T18086.hs +++ b/testsuite/tests/stranal/sigs/T18086.hs @@ -13,7 +13,7 @@ m = do putStrLn "foo" error "bar" --- Dito, just in a more complex scenario (the original reproducer of #18086) +-- Ditto, just in a more complex scenario (the original reproducer of #18086) panic :: String -> a panic x = unsafeDupablePerformIO $ do stack <- ccsToStrings =<< getCurrentCCS x diff --git a/testsuite/tests/typecheck/should_fail/T17173.hs b/testsuite/tests/typecheck/should_fail/T17173.hs index d26c5dd619..e1c3dbfc0c 100644 --- a/testsuite/tests/typecheck/should_fail/T17173.hs +++ b/testsuite/tests/typecheck/should_fail/T17173.hs @@ -2,5 +2,5 @@ module T17173 where --- This now fails with eager instantation +-- This now fails with eager instantiation foo = (let myId :: forall a. a -> a; myId x = x in myId) @Bool True diff --git a/testsuite/tests/typecheck/should_fail/TcCoercibleFail.hs b/testsuite/tests/typecheck/should_fail/TcCoercibleFail.hs index 01afc9cb42..fc3e7b583e 100644 --- a/testsuite/tests/typecheck/should_fail/TcCoercibleFail.hs +++ b/testsuite/tests/typecheck/should_fail/TcCoercibleFail.hs @@ -22,7 +22,7 @@ foo5 = coerce :: Void -> () ------------------------------------ --- This next one generates an exponentally big type as it +-- This next one generates an exponentially big type as it -- tries to unwrap. See comment:15 in #11518 -- Adding assertions that force the types can make us -- run out of space. |