diff options
54 files changed, 97 insertions, 170 deletions
diff --git a/compiler/GHC/Builtin/Names.hs b/compiler/GHC/Builtin/Names.hs index c0ebb2929b..905fb6c8dc 100644 --- a/compiler/GHC/Builtin/Names.hs +++ b/compiler/GHC/Builtin/Names.hs @@ -219,7 +219,6 @@ basicKnownKeyNames monoidClassName, memptyName, mappendName, mconcatName, -- The IO type - -- See Note [TyConRepNames for non-wired-in TyCons] ioTyConName, ioDataConName, runMainIOName, runRWName, diff --git a/compiler/GHC/CmmToAsm/X86/CodeGen.hs b/compiler/GHC/CmmToAsm/X86/CodeGen.hs index bf799590cd..21a094008e 100644 --- a/compiler/GHC/CmmToAsm/X86/CodeGen.hs +++ b/compiler/GHC/CmmToAsm/X86/CodeGen.hs @@ -3245,7 +3245,7 @@ genCCall64' target dest_regs args = do -- Align stack to 16n for calls, assuming a starting stack -- alignment of 16n - word_size on procedure entry. Which we - -- maintain. See Note [rts/StgCRun.c : Stack Alignment on X86] + -- maintain. See Note [Stack Alignment on X86] in rts/StgCRun.c let word_size = platformWordSizeInBytes platform (real_size, adjust_rsp) <- if (tot_arg_size + word_size) `rem` 16 == 0 diff --git a/compiler/GHC/CmmToC.hs b/compiler/GHC/CmmToC.hs index 9539208883..60059124b2 100644 --- a/compiler/GHC/CmmToC.hs +++ b/compiler/GHC/CmmToC.hs @@ -497,7 +497,7 @@ machOpNeedsCast platform mop args -- resultRepOfMachOp says). | isComparisonMachOp mop = Just mkW_ - -- See Note [Zero-extended sub-word signed results] + -- See Note [Zero-extending sub-word signed results] | signedOp mop , res_ty <- machOpResultType platform mop args , not $ isFloatType res_ty -- only integer operations, not MO_SF_Conv diff --git a/compiler/GHC/CmmToLlvm/Config.hs b/compiler/GHC/CmmToLlvm/Config.hs index 5f5fedc9a7..84455a8b2c 100644 --- a/compiler/GHC/CmmToLlvm/Config.hs +++ b/compiler/GHC/CmmToLlvm/Config.hs @@ -26,6 +26,6 @@ data LlvmCgConfig = LlvmCgConfig , llvmCgDoWarn :: !Bool -- ^ True ==> warn unsupported Llvm version , llvmCgLlvmTarget :: !String -- ^ target triple passed to LLVM , llvmCgLlvmConfig :: !LlvmConfig -- ^ mirror DynFlags LlvmConfig. - -- see Note [LLVM Configuration] in "GHC.SysTools". This can be strict since + -- see Note [LLVM configuration] in "GHC.SysTools". This can be strict since -- GHC.Driver.Config.CmmToLlvm.initLlvmCgConfig verifies the files are present. } diff --git a/compiler/GHC/Core.hs b/compiler/GHC/Core.hs index 15a0674e38..4fac9ce8e1 100644 --- a/compiler/GHC/Core.hs +++ b/compiler/GHC/Core.hs @@ -1120,7 +1120,7 @@ data CoreRule -- arguments, it simply discards them; the returned 'CoreExpr' -- is just the rewrite of 'ru_fn' applied to the first 'ru_nargs' args } - -- See Note [Extra args in rule matching] in GHC.Core.Rules + -- See Note [Extra args in the target] in GHC.Core.Rules -- | Rule options data RuleOpts = RuleOpts diff --git a/compiler/GHC/Core/Coercion/Axiom.hs b/compiler/GHC/Core/Coercion/Axiom.hs index 2476cfd7cc..4e0aa45abc 100644 --- a/compiler/GHC/Core/Coercion/Axiom.hs +++ b/compiler/GHC/Core/Coercion/Axiom.hs @@ -323,7 +323,7 @@ isImplicitCoAxiom = co_ax_implicit coAxBranchIncomps :: CoAxBranch -> [CoAxBranch] coAxBranchIncomps = cab_incomps --- See Note [Compatibility checking] in GHC.Core.FamInstEnv +-- See Note [Compatibility] in GHC.Core.FamInstEnv placeHolderIncomps :: [CoAxBranch] placeHolderIncomps = panic "placeHolderIncomps" diff --git a/compiler/GHC/Core/Lint.hs b/compiler/GHC/Core/Lint.hs index c79ce8be1d..b93df23356 100644 --- a/compiler/GHC/Core/Lint.hs +++ b/compiler/GHC/Core/Lint.hs @@ -486,7 +486,7 @@ lintCoreBindings dflags pass local_in_scope binds -- we have eta-expanded data constructors with representation-polymorphic -- bindings; so we switch off the representation-polymorphism checks. -- The very simple optimiser will beta-reduce them away. - -- See Note [Checking representation-polymorphic data constructors] + -- See Note [Checking for representation-polymorphic built-ins] -- in GHC.HsToCore.Expr. check_fixed_rep = case pass of CoreDesugar -> False @@ -1920,7 +1920,7 @@ conceivably we could allow it. But we can always eta-expand such an "undersaturated" rule (see 'GHC.Core.Opt.Arity.etaExpandToJoinPointRule'), and in fact the simplifier would have to in order to deal with the RHS. So we take a conservative view and don't allow undersaturated rules for join points. See -Note [Rules and join points] in "GHC.Core.Opt.OccurAnal" for further discussion. +Note [Join points and unfoldings/rules] in "GHC.Core.Opt.OccurAnal" for further discussion. -} {- diff --git a/compiler/GHC/Core/Make.hs b/compiler/GHC/Core/Make.hs index 06cb867c94..200847134b 100644 --- a/compiler/GHC/Core/Make.hs +++ b/compiler/GHC/Core/Make.hs @@ -1031,7 +1031,7 @@ the first. But the stable-unfolding for f looks like \x. case x of MkT a b -> g ($WMkT b a) where $WMkT is the wrapper for MkT that evaluates its arguments. We apply the same w/w split to this unfolding (see Note [Worker/wrapper -for INLINEABLE functions] in GHC.Core.Opt.WorkWrap) so the template ends up like +for INLINABLE functions] in GHC.Core.Opt.WorkWrap) so the template ends up like \b. let a = absentError "blah" x = MkT a b in case x of MkT a b -> g ($WMkT b a) diff --git a/compiler/GHC/Core/Opt/Arity.hs b/compiler/GHC/Core/Opt/Arity.hs index ceef44afbf..ab38be413c 100644 --- a/compiler/GHC/Core/Opt/Arity.hs +++ b/compiler/GHC/Core/Opt/Arity.hs @@ -1495,7 +1495,7 @@ etaInfoApp in_scope expr eis = go subst e (EI bs mco') where mco' = checkReflexiveMCo (Core.substCo subst co `mkTransMCoR` mco) - -- See Note [Check for reflexive casts in eta-expansion] + -- See Note [Check for reflexive casts in eta expansion] go subst (Case e b ty alts) eis = Case (Core.substExprSC subst e) b1 ty' alts' diff --git a/compiler/GHC/Core/Opt/CSE.hs b/compiler/GHC/Core/Opt/CSE.hs index 08d4ce193b..4f6917d554 100644 --- a/compiler/GHC/Core/Opt/CSE.hs +++ b/compiler/GHC/Core/Opt/CSE.hs @@ -435,8 +435,8 @@ addBinding :: CSEnv -- Includes InId->OutId cloning -- Extend the CSE env with a mapping [rhs -> out-id] -- unless we can instead just substitute [in-id -> rhs] -- --- It's possible for the binder to be a type variable (see --- Note [Type-let] in GHC.Core), in which case we can just substitute. +-- It's possible for the binder to be a type variable, +-- in which case we can just substitute. addBinding env in_id out_id rhs' cse_done | not (isId in_id) = (extendCSSubst env in_id rhs', out_id) | noCSE in_id = (env, out_id) diff --git a/compiler/GHC/Core/Opt/FloatIn.hs b/compiler/GHC/Core/Opt/FloatIn.hs index 37cb23e338..abd56abdf0 100644 --- a/compiler/GHC/Core/Opt/FloatIn.hs +++ b/compiler/GHC/Core/Opt/FloatIn.hs @@ -541,7 +541,7 @@ fiBind platform to_drop (AnnRec bindings) body_fvs (ids, rhss) = unzip bindings rhss_fvs = map freeVarsOf rhss - -- See Note [extra_fvs (1,2)] + -- See Note [extra_fvs (1)] and Note [extra_fvs (2)] rule_fvs = mapUnionDVarSet bndrRuleAndUnfoldingVarsDSet ids extra_fvs = rule_fvs `unionDVarSet` unionDVarSets [ rhs_fvs | (bndr, (rhs_fvs, rhs)) <- bindings diff --git a/compiler/GHC/Core/Opt/OccurAnal.hs b/compiler/GHC/Core/Opt/OccurAnal.hs index c5e4dee1a0..901bc83077 100644 --- a/compiler/GHC/Core/Opt/OccurAnal.hs +++ b/compiler/GHC/Core/Opt/OccurAnal.hs @@ -341,7 +341,7 @@ something at the bottom: RULE: B.f @Int = $sf Applying this rule makes foo refer to $sf, although foo doesn't appear to -depend on $sf. (And, as in Note [Rules for imported functions], the +depend on $sf. (And, as in Note [IMP-RULES: local rules for imported functions], the dependency might be more indirect. For example, foo might mention C.t rather than B.f, where C.t eventually inlines to B.f.) @@ -573,13 +573,13 @@ Consider this group, which is typical of what SpecConstr builds: So 'f' and 'fs' are in the same Rec group (since f refers to fs via its RULE). But watch out! If 'fs' is not chosen as a loop breaker, we may get an infinite loop: - - the RULE is applied in f's RHS (see Note [Self-recursive rules] in GHC.Core.Opt.Simplify + - the RULE is applied in f's RHS (see Note [Rules for recursive functions] in GHC.Core.Opt.Simplify - fs is inlined (say it's small) - now there's another opportunity to apply the RULE This showed up when compiling Control.Concurrent.Chan.getChanContents. Hence the transitive rule_fv_env stuff described in -Note [Rules and loop breakers]. +Note [Rules and loop breakers]. ------------------------------------------------------------ Note [Finding join points] @@ -1735,7 +1735,7 @@ lambda and casts, e.g. * Why do we take care to account for intervening casts? Answer: currently we don't do eta-expansion and cast-swizzling in a stable - unfolding (see Note [Eta-expansion inside stable unfoldings]). + unfolding (see Note [Eta-expansion in stable unfoldings]). So we can get f = \x. ((\y. ...x...y...) |> co) Now, since the lambdas aren't together, the occurrence analyser will diff --git a/compiler/GHC/Core/Opt/Pipeline.hs b/compiler/GHC/Core/Opt/Pipeline.hs index 3f8e3fc186..1320d9d3ec 100644 --- a/compiler/GHC/Core/Opt/Pipeline.hs +++ b/compiler/GHC/Core/Opt/Pipeline.hs @@ -621,7 +621,7 @@ simplExprGently :: SimplEnv -> CoreExpr -> SimplM CoreExpr -- enforce that; it just simplifies the expression twice -- It's important that simplExprGently does eta reduction; see --- Note [Simplifying the left-hand side of a RULE] above. The +-- Note [Simplify rule LHS] above. The -- simplifier does indeed do eta reduction (it's in GHC.Core.Opt.Simplify.completeLam) -- but only if -O is on. @@ -934,7 +934,7 @@ type IndEnv = IdEnv (Id, [CoreTickish]) -- Maps local_id -> exported_id, ticks shortOutIndirections :: CoreProgram -> CoreProgram shortOutIndirections binds | isEmptyVarEnv ind_env = binds - | no_need_to_flatten = binds' -- See Note [Rules and indirect-zapping] + | no_need_to_flatten = binds' -- See Note [Rules and indirection-zapping] | otherwise = [Rec (flattenBinds binds')] -- for this no_need_to_flatten stuff where ind_env = makeIndEnv binds @@ -996,7 +996,7 @@ shortMeOut ind_env exported_id local_id not (local_id `elemVarEnv` ind_env) -- Only if not already substituted for then if hasShortableIdInfo exported_id - then True -- See Note [Messing up the exported Id's IdInfo] + then True -- See Note [Messing up the exported Id's RULES] else warnPprTrace True "Not shorting out" (ppr exported_id) False else False @@ -1005,7 +1005,7 @@ shortMeOut ind_env exported_id local_id hasShortableIdInfo :: Id -> Bool -- True if there is no user-attached IdInfo on exported_id, -- so we can safely discard it --- See Note [Messing up the exported Id's IdInfo] +-- See Note [Messing up the exported Id's RULES] hasShortableIdInfo id = isEmptyRuleInfo (ruleInfo info) && isDefaultInlinePragma (inlinePragInfo info) diff --git a/compiler/GHC/Core/Opt/Simplify.hs b/compiler/GHC/Core/Opt/Simplify.hs index 575512b7c8..f77411e0b1 100644 --- a/compiler/GHC/Core/Opt/Simplify.hs +++ b/compiler/GHC/Core/Opt/Simplify.hs @@ -669,7 +669,7 @@ mkCastWrapperInlinePrag :: InlinePragma -> InlinePragma -- See Note [Cast worker/wrapper] mkCastWrapperInlinePrag (InlinePragma { inl_act = act, inl_rule = rule_info }) = InlinePragma { inl_src = SourceText "{-# INLINE" - , inl_inline = NoUserInlinePrag -- See Note [Wrapper NoUserInline] + , inl_inline = NoUserInlinePrag -- See Note [Wrapper NoUserInlinePrag] , inl_sat = Nothing -- in GHC.Core.Opt.WorkWrap , inl_act = wrap_act -- See Note [Wrapper activation] , inl_rule = rule_info } -- in GHC.Core.Opt.WorkWrap @@ -2087,7 +2087,7 @@ rebuildCall env info@(ArgInfo { ai_fun = fun, ai_args = rev_args | nr_wanted == 0 || no_more_args , let info' = info { ai_rules = Nothing } = -- We've accumulated a simplified call in <fun,rev_args> - -- so try rewrite rules; see Note [RULEs apply to simplified arguments] + -- so try rewrite rules; see Note [RULES apply to simplified arguments] -- See also Note [Rules for recursive functions] do { mb_match <- tryRules env rules fun (reverse rev_args) cont ; case mb_match of diff --git a/compiler/GHC/Core/Opt/Simplify/Utils.hs b/compiler/GHC/Core/Opt/Simplify/Utils.hs index 13a8a1b853..ec26ba89fb 100644 --- a/compiler/GHC/Core/Opt/Simplify/Utils.hs +++ b/compiler/GHC/Core/Opt/Simplify/Utils.hs @@ -130,7 +130,7 @@ data SimplCont | ApplyToVal -- (ApplyToVal arg K)[e] = K[ e arg ] { sc_dup :: DupFlag -- See Note [DupFlag invariants] , sc_hole_ty :: OutType -- Type of the function, presumably (forall a. blah) - -- See Note [The hole type in ApplyToTy/Val] + -- See Note [The hole type in ApplyToTy] , sc_arg :: InExpr -- The argument, , sc_env :: StaticEnv -- see Note [StaticEnv invariant] , sc_cont :: SimplCont } @@ -138,7 +138,7 @@ data SimplCont | ApplyToTy -- (ApplyToTy ty K)[e] = K[ e ty ] { sc_arg_ty :: OutType -- Argument type , sc_hole_ty :: OutType -- Type of the function, presumably (forall a. blah) - -- See Note [The hole type in ApplyToTy/Val] + -- See Note [The hole type in ApplyToTy] , sc_cont :: SimplCont } | Select -- (Select alts K)[e] = K[ case e of alts ] @@ -453,7 +453,7 @@ contHoleType (StrictBind { sc_bndr = b, sc_dup = dup, sc_env = se }) = perhapsSubstTy dup se (idType b) contHoleType (StrictArg { sc_fun_ty = ty }) = funArgTy ty contHoleType (ApplyToTy { sc_hole_ty = ty }) = ty -- See Note [The hole type in ApplyToTy] -contHoleType (ApplyToVal { sc_hole_ty = ty }) = ty -- See Note [The hole type in ApplyToTy/Val] +contHoleType (ApplyToVal { sc_hole_ty = ty }) = ty -- See Note [The hole type in ApplyToTy] contHoleType (Select { sc_dup = d, sc_bndr = b, sc_env = se }) = perhapsSubstTy d se (idType b) @@ -1621,7 +1621,7 @@ mkLam env bndrs body cont = do { tick (EtaReduction (head bndrs)) ; return etad_lam } - | not (contIsRhs cont) -- See Note [Eta-expanding lambdas] + | not (contIsRhs cont) -- See Note [Eta expanding lambdas] , sm_eta_expand mode , any isRuntimeVar bndrs , let body_arity = {-# SCC "eta" #-} exprEtaExpandArity dflags body @@ -2192,9 +2192,9 @@ prepareAlts scrut case_bndr' alts mkCase tries these things -* Note [Merge nested cases] -* Note [Eliminate identity case] -* Note [Scrutinee constant folding] +* Note [Merge Nested Cases] +* Note [Eliminate Identity Case] +* Note [Scrutinee Constant Folding] Note [Merge Nested Cases] ~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/compiler/GHC/Core/Rules.hs b/compiler/GHC/Core/Rules.hs index 93ab0608a8..2eabc1db0c 100644 --- a/compiler/GHC/Core/Rules.hs +++ b/compiler/GHC/Core/Rules.hs @@ -882,7 +882,7 @@ match renv subst (Type ty1) (Type ty2) _mco = match_ty renv subst ty1 ty2 ------------------------ Coercions --------------------- --- See Note [Coercion argument] for why this isn't really right +-- See Note [Coercion arguments] for why this isn't really right match renv subst (Coercion co1) (Coercion co2) MRefl = match_co renv subst co1 co2 -- The MCo case corresponds to matching co ~ (co2 |> co3) @@ -1054,7 +1054,7 @@ eta_reduce renv e@(Lam {}) eta_reduce _ _ = Nothing -{- Note [Eta reduction the target] +{- Note [Eta reduction in the target] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Suppose we are faced with this (#19790) Template {x} f x diff --git a/compiler/GHC/Core/TyCo/Subst.hs b/compiler/GHC/Core/TyCo/Subst.hs index 32817ca6c7..a5cb32e38e 100644 --- a/compiler/GHC/Core/TyCo/Subst.hs +++ b/compiler/GHC/Core/TyCo/Subst.hs @@ -113,7 +113,7 @@ data TCvSubst TvSubstEnv -- Substitutes both type and kind variables CvSubstEnv -- Substitutes coercion variables -- See Note [Substitutions apply only once] - -- and Note [Extending the TvSubstEnv] + -- and Note [Extending the TCvSubstEnv] -- and Note [Substituting types and coercions] -- and Note [The substitution invariant] @@ -258,7 +258,7 @@ mkEmptyTCvSubst :: InScopeSet -> TCvSubst mkEmptyTCvSubst is = TCvSubst is emptyTvSubstEnv emptyCvSubstEnv isEmptyTCvSubst :: TCvSubst -> Bool - -- See Note [Extending the TvSubstEnv] + -- See Note [Extending the TCvSubstEnv] isEmptyTCvSubst (TCvSubst _ tenv cenv) = isEmptyVarEnv tenv && isEmptyVarEnv cenv mkTCvSubst :: InScopeSet -> (TvSubstEnv, CvSubstEnv) -> TCvSubst diff --git a/compiler/GHC/Driver/Session.hs b/compiler/GHC/Driver/Session.hs index 838f0bf3b7..c3375ea114 100644 --- a/compiler/GHC/Driver/Session.hs +++ b/compiler/GHC/Driver/Session.hs @@ -449,7 +449,7 @@ data DynFlags = DynFlags { llvmConfig :: LlvmConfig, -- ^ N.B. It's important that this field is lazy since we load the LLVM - -- configuration lazily. See Note [LLVM Configuration] in "GHC.SysTools". + -- configuration lazily. See Note [LLVM configuration] in "GHC.SysTools". llvmOptLevel :: Int, -- ^ LLVM optimisation level verbosity :: Int, -- ^ Verbosity level: see Note [Verbosity levels] debugLevel :: Int, -- ^ How much debug information to produce @@ -773,7 +773,7 @@ data LlvmTarget = LlvmTarget , lAttributes :: [String] } --- | See Note [LLVM Configuration] in "GHC.SysTools". +-- | See Note [LLVM configuration] in "GHC.SysTools". data LlvmConfig = LlvmConfig { llvmTargets :: [(String, LlvmTarget)] , llvmPasses :: [(Int, String)] } diff --git a/compiler/GHC/HsToCore/Expr.hs b/compiler/GHC/HsToCore/Expr.hs index 4e4eca8cef..973d7f204f 100644 --- a/compiler/GHC/HsToCore/Expr.hs +++ b/compiler/GHC/HsToCore/Expr.hs @@ -1042,7 +1042,6 @@ dsConLike con tvbs tys = do { ds_con <- dsHsConLike con ; ids <- newSysLocalsDs tys -- newSysLocalDs: /can/ be lev-poly; see - -- Note [Checking representation-polymorphic data constructors] ; return (mkLams tvs $ mkLams ids $ ds_con `mkTyApps` mkTyVarTys tvs diff --git a/compiler/GHC/HsToCore/Pmc/Desugar.hs b/compiler/GHC/HsToCore/Pmc/Desugar.hs index 629f32f3cd..7cba784245 100644 --- a/compiler/GHC/HsToCore/Pmc/Desugar.hs +++ b/compiler/GHC/HsToCore/Pmc/Desugar.hs @@ -74,7 +74,7 @@ vanillaConGrd scrut con arg_ids = -- where @b@ and @c@ are freshly allocated in @mkListGrds@ and @a@ is the match -- variable. mkListGrds :: Id -> [(Id, [PmGrd])] -> DsM [PmGrd] --- See Note [Order of guards matter] for why we need to intertwine guards +-- See Note [Order of guards matters] for why we need to intertwine guards -- on list elements. mkListGrds a [] = pure [vanillaConGrd a nilDataCon []] mkListGrds a ((x, head_grds):xs) = do diff --git a/compiler/GHC/HsToCore/Utils.hs b/compiler/GHC/HsToCore/Utils.hs index 2ea1bb3cbe..17b2b42917 100644 --- a/compiler/GHC/HsToCore/Utils.hs +++ b/compiler/GHC/HsToCore/Utils.hs @@ -183,7 +183,7 @@ In fact, even GHC.Core.Subst.simplOptExpr will do this, and simpleOptExpr runs on the output of the desugarer, so all is well by the end of the desugaring pass. -See also Note [MatchIds] in GHC.HsToCore.Match +See also Note [Match Ids] in GHC.HsToCore.Match ************************************************************************ * * diff --git a/compiler/GHC/Iface/Type.hs-boot b/compiler/GHC/Iface/Type.hs-boot index c840f9af51..9c10f29ed5 100644 --- a/compiler/GHC/Iface/Type.hs-boot +++ b/compiler/GHC/Iface/Type.hs-boot @@ -5,7 +5,7 @@ module GHC.Iface.Type where -- Empty import to influence the compilation ordering. --- See Note [Depend on GHC.Integer] in GHC.Base +-- See Note [Depend on GHC.Num.Integer] in GHC.Base import GHC.Base () data IfaceAppArgs diff --git a/compiler/GHC/Linker/Types.hs b/compiler/GHC/Linker/Types.hs index d1131a70f0..17bb46feb9 100644 --- a/compiler/GHC/Linker/Types.hs +++ b/compiler/GHC/Linker/Types.hs @@ -125,7 +125,7 @@ data Unlinked [SptEntry] -- ^ A byte-code object, lives only in memory. Also -- carries some static pointer table entries which -- should be loaded along with the BCOs. - -- See Note [Grant plan for static forms] in + -- See Note [Grand plan for static forms] in -- "GHC.Iface.Tidy.StaticPtrTable". instance Outputable Unlinked where diff --git a/compiler/GHC/Rename/HsType.hs b/compiler/GHC/Rename/HsType.hs index 145e6f08ec..1e1a0b538f 100644 --- a/compiler/GHC/Rename/HsType.hs +++ b/compiler/GHC/Rename/HsType.hs @@ -961,8 +961,8 @@ bindHsQTyVars :: forall a b. -> (LHsQTyVars GhcRn -> Bool -> RnM (b, FreeVars)) -- The Bool is True <=> all kind variables used in the -- kind signature are bound on the left. Reason: - -- the last clause of Note [CUSKs: Complete user-supplied - -- kind signatures] in GHC.Hs.Decls + -- the last clause of Note [CUSKs: complete user-supplied kind signatures] + -- in GHC.Hs.Decls -> RnM (b, FreeVars) -- See Note [bindHsQTyVars examples] diff --git a/compiler/GHC/Rename/Unbound.hs b/compiler/GHC/Rename/Unbound.hs index 6d48ea3074..5639d2a6c6 100644 --- a/compiler/GHC/Rename/Unbound.hs +++ b/compiler/GHC/Rename/Unbound.hs @@ -401,7 +401,7 @@ nameSpacesRelated dflags what_looking ns ns' promoted_datacons = [(dataName, [WL_Constructor]) | data_kinds] {- -Note [Related name space] +Note [Related name spaces] ~~~~~~~~~~~~~~~~~~~~~~~~~ Name spaces are related if there is a chance to mean the one when one writes the other, i.e. variables <-> data constructors and type variables <-> type diff --git a/compiler/GHC/StgToCmm/DataCon.hs b/compiler/GHC/StgToCmm/DataCon.hs index 6a25562f6a..bed2f164eb 100644 --- a/compiler/GHC/StgToCmm/DataCon.hs +++ b/compiler/GHC/StgToCmm/DataCon.hs @@ -227,7 +227,7 @@ buildDynCon' binder mn actually_bound ccs con args For Char/Int closures there are some value closures built into the RTS. This is the case for all values in the range mINT_INTLIKE .. mAX_INTLIKE (or CHARLIKE). -See Note [CHARLIKE and INTLIKE closures.] in the RTS code. +See Note [CHARLIKE and INTLIKE closures] in the RTS code. Similarly zero-arity constructors have a closure in their defining Module we can use. diff --git a/compiler/GHC/StgToCmm/Expr.hs b/compiler/GHC/StgToCmm/Expr.hs index d82c9f6ff4..3a3c1db647 100644 --- a/compiler/GHC/StgToCmm/Expr.hs +++ b/compiler/GHC/StgToCmm/Expr.hs @@ -71,7 +71,7 @@ cgExpr (StgOpApp (StgPrimOp SeqOp) [StgVarArg a, _] _res_ty) = cgIdApp a [] -- dataToTag# :: a -> Int# --- See Note [dataToTag# magic] in primops.txt.pp +-- See Note [dataToTag# magic] in GHC.Core.Opt.ConstantFold cgExpr (StgOpApp (StgPrimOp DataToTagOp) [StgVarArg a] _res_ty) = do platform <- getPlatform emitComment (mkFastString "dataToTag#") @@ -538,7 +538,7 @@ isSimpleScrut _ _ = return False isSimpleOp :: StgOp -> [StgArg] -> FCode Bool -- True iff the op cannot block or allocate isSimpleOp (StgFCallOp (CCall (CCallSpec _ _ safe)) _) _ = return $! not (playSafe safe) --- dataToTag# evaluates its argument, see Note [dataToTag#] in primops.txt.pp +-- dataToTag# evaluates its argument, see Note [dataToTag# magic] in GHC.Core.Opt.ConstantFold isSimpleOp (StgPrimOp DataToTagOp) _ = return False isSimpleOp (StgPrimOp op) stg_args = do arg_exprs <- getNonVoidArgAmodes stg_args diff --git a/compiler/GHC/StgToCmm/Foreign.hs b/compiler/GHC/StgToCmm/Foreign.hs index cc33576240..e71c418530 100644 --- a/compiler/GHC/StgToCmm/Foreign.hs +++ b/compiler/GHC/StgToCmm/Foreign.hs @@ -174,7 +174,7 @@ We will now generate this: L2: ... r ... -And when the safe foreign call is lowered later (see Note [lower safe +And when the safe foreign call is lowered later (see Note [Lower safe foreign calls]) we get this: suspendThread() diff --git a/compiler/GHC/Tc/Deriv/Utils.hs b/compiler/GHC/Tc/Deriv/Utils.hs index 91a11c9af6..8a5b376767 100644 --- a/compiler/GHC/Tc/Deriv/Utils.hs +++ b/compiler/GHC/Tc/Deriv/Utils.hs @@ -625,7 +625,7 @@ Currently, the only three stock derived classes that require this are Read, Show, and Generic, as their derived code all depend on the record selectors of the derived data type's constructors. -See also Note [Newtype deriving and unused constructors] in GHC.Tc.Deriv for +See also Note [Unused constructors and deriving clauses] in GHC.Tc.Deriv for another example of a similar trick. -} diff --git a/compiler/GHC/Tc/Errors/Hole.hs b/compiler/GHC/Tc/Errors/Hole.hs index 7d1388c112..4115d6b198 100644 --- a/compiler/GHC/Tc/Errors/Hole.hs +++ b/compiler/GHC/Tc/Errors/Hole.hs @@ -205,7 +205,7 @@ When we now check whether `x :: a_a1pa[sk:2]` fits the hole in `tcCheckHoleFit`, the call to `tcSubType` will end up unifying the meta type variable `a0_a1pd[tau:2] := a_a1pa[sk:2]`. By wrapping the wanted constraints needed by tcSubType_NC and the relevant constraints (see Note [Relevant -Constraints] for more details) in the nested implications, we can pass the +constraints] for more details) in the nested implications, we can pass the information in the givens along to the simplifier. For our example, we end up needing to check whether the following constraints are soluble. @@ -982,7 +982,7 @@ tcCheckHoleFit (TypedHole {..}) hole_ty ty = discardErrs $ -- the wanteds, because they are freshly generated by the -- call to`tcSubtype_NC`. ; traceTc "final_wc is: " $ ppr final_wc - -- See Note [Speeding up valid-hole fits] + -- See Note [Speeding up valid hole-fits] ; (rem, _) <- tryTc $ runTcSDerivedsEarlyAbort $ simplifyTopWanteds final_wc ; traceTc "}" empty ; return (any isSolvedWC rem, wrap) diff --git a/compiler/GHC/Tc/Errors/Types.hs b/compiler/GHC/Tc/Errors/Types.hs index 04b3acefa0..e292d864d8 100644 --- a/compiler/GHC/Tc/Errors/Types.hs +++ b/compiler/GHC/Tc/Errors/Types.hs @@ -125,7 +125,7 @@ existence of these two types, which for now remain a "necessary evil". -} -- The majority of TcRn messages come with extra context about the error, --- and this newtype captures it. See Note [Migrating TcM messages]. +-- and this newtype captures it. See Note [Migrating TcM Messages]. data ErrInfo = ErrInfo { errInfoContext :: !SDoc -- ^ Extra context associated to the error. diff --git a/compiler/GHC/Tc/Gen/HsType.hs b/compiler/GHC/Tc/Gen/HsType.hs index 2a3ef6fd10..204edcb0b0 100644 --- a/compiler/GHC/Tc/Gen/HsType.hs +++ b/compiler/GHC/Tc/Gen/HsType.hs @@ -1177,7 +1177,7 @@ tc_hs_type mode (HsForAllTy { hst_tele = tele, hst_body = ty }) exp_kind -- Pass on the mode from the type, to any wildcards -- in kind signatures on the forall'd variables -- e.g. f :: _ -> Int -> forall (a :: _). blah - -- Why exp_kind? See Note [Body kind of HsForAllTy] + -- Why exp_kind? See Note [Body kind of a HsForAllTy] -- Do not kind-generalise here! See Note [Kind generalisation] @@ -3149,7 +3149,7 @@ tcOuterTKBndrs skol_info , sm_tvtv = SMDSkolemTv skol_info }) skol_info -- Do not clone the outer binders - -- See Note [Cloning for type variable binder] under "must not" + -- See Note [Cloning for type variable binders] under "must not" tcOuterTKBndrsX :: OutputableBndrFlag flag 'Renamed => SkolemMode -> SkolemInfo diff --git a/compiler/GHC/Tc/Gen/Pat.hs b/compiler/GHC/Tc/Gen/Pat.hs index 132f58b7b4..ae9667804d 100644 --- a/compiler/GHC/Tc/Gen/Pat.hs +++ b/compiler/GHC/Tc/Gen/Pat.hs @@ -918,7 +918,7 @@ tcDataConPat penv (L con_span con_name) data_con pat_ty_scaled ; (tenv, ex_tvs') <- tcInstSuperSkolTyVarsX skol_info tenv1 ex_tvs -- Get location from monad, not from ex_tvs -- This freshens: See Note [Freshen existentials] - -- Why "super"? See Note [Binding when lookup up instances] + -- Why "super"? See Note [Binding when looking up instances] -- in GHC.Core.InstEnv. ; let arg_tys' = substScaledTys tenv arg_tys diff --git a/compiler/GHC/Tc/Gen/Sig.hs b/compiler/GHC/Tc/Gen/Sig.hs index 82a3290e4c..ed1833c1e7 100644 --- a/compiler/GHC/Tc/Gen/Sig.hs +++ b/compiler/GHC/Tc/Gen/Sig.hs @@ -409,7 +409,7 @@ tcPatSynSig name sig_ty@(L _ (HsSig{sig_bndrs = hs_outer_bndrs, sig_body = hs_ty ; skol_info <- mkSkolemInfo (DataConSkol name) ; (tclvl, wanted, (outer_bndrs, (ex_bndrs, (req, prov, body_ty)))) <- pushLevelAndSolveEqualitiesX "tcPatSynSig" $ - -- See Note [solveEqualities in tcPatSynSig] + -- See Note [Report unsolved equalities in tcPatSynSig] tcOuterTKBndrs skol_info hs_outer_bndrs $ tcExplicitTKBndrs skol_info ex_hs_tvbndrs $ do { req <- tcHsContext hs_req diff --git a/compiler/GHC/Tc/Module.hs b/compiler/GHC/Tc/Module.hs index c8f65e2453..34a02e70ec 100644 --- a/compiler/GHC/Tc/Module.hs +++ b/compiler/GHC/Tc/Module.hs @@ -1898,7 +1898,7 @@ generateMainBinding tcg_env main_name = do ; (ev_binds, main_expr) <- setMainCtxt main_name io_ty $ tcCheckMonoExpr main_expr_rn io_ty - -- See Note [Root-main Id] + -- See Note [Root-main id] -- Construct the binding -- :Main.main :: IO res_ty = runMainIO res_ty main ; run_main_id <- tcLookupId runMainIOName diff --git a/compiler/GHC/Tc/Solver/Canonical.hs b/compiler/GHC/Tc/Solver/Canonical.hs index 347696f874..1643a0ef46 100644 --- a/compiler/GHC/Tc/Solver/Canonical.hs +++ b/compiler/GHC/Tc/Solver/Canonical.hs @@ -496,7 +496,7 @@ the sc_theta_ids at all. So our final construction is -} makeSuperClasses :: [Ct] -> TcS [Ct] --- Returns strict superclasses, transitively, see Note [The superclasses story] +-- Returns strict superclasses, transitively, see Note [The superclass story] -- See Note [The superclass story] -- The loop-breaking here follows Note [Expanding superclasses] in GHC.Tc.Utils.TcType -- Specifically, for an incoming (C t) constraint, we return all of (C t)'s @@ -1392,7 +1392,7 @@ can_eq_nc_forall ev eq_rel s1 s2 | otherwise = do { traceTcS "Omitting decomposition of given polytype equality" $ - pprEq s1 s2 -- See Note [Do not decompose given polytype equalities] + pprEq s1 s2 -- See Note [Do not decompose Given polytype equalities] ; stopWith ev "Discard given polytype equality" } where diff --git a/compiler/GHC/Tc/Solver/Monad.hs b/compiler/GHC/Tc/Solver/Monad.hs index 963768ca47..2cd004053d 100644 --- a/compiler/GHC/Tc/Solver/Monad.hs +++ b/compiler/GHC/Tc/Solver/Monad.hs @@ -1340,7 +1340,7 @@ runTcSDeriveds tcs -- | This variant of 'runTcSDeriveds' will immediatley fail upon encountering an --- insoluble ct. See Note [Speeding up valid-hole fits] +-- insoluble ct. See Note [Speeding up valid hole-fits] runTcSDerivedsEarlyAbort :: TcS a -> TcM a runTcSDerivedsEarlyAbort tcs = do { ev_binds_var <- TcM.newTcEvBinds diff --git a/compiler/GHC/Tc/Types.hs b/compiler/GHC/Tc/Types.hs index a784eb5719..97f11c8a0b 100644 --- a/compiler/GHC/Tc/Types.hs +++ b/compiler/GHC/Tc/Types.hs @@ -1169,7 +1169,7 @@ instance Outputable TcTyThing where -- Debugging only -- b) to figure out when a nested binding can be generalised, -- in 'GHC.Tc.Gen.Bind.decideGeneralisationPlan'. -- -data IdBindingInfo -- See Note [Meaning of IdBindingInfo and ClosedTypeId] +data IdBindingInfo -- See Note [Meaning of IdBindingInfo] = NotLetBound | ClosedLet | NonClosedLet @@ -1192,7 +1192,7 @@ type RhsNames = NameSet -- Names of variables, mentioned on the RHS of -- a definition, that are not Global or ClosedLet type ClosedTypeId = Bool - -- See Note [Meaning of IdBindingInfo and ClosedTypeId] + -- See Note [Meaning of IdBindingInfo] {- Note [Meaning of IdBindingInfo] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/compiler/GHC/Tc/Utils/TcMType.hs b/compiler/GHC/Tc/Utils/TcMType.hs index 22f9b14d26..1ece974166 100644 --- a/compiler/GHC/Tc/Utils/TcMType.hs +++ b/compiler/GHC/Tc/Utils/TcMType.hs @@ -1971,7 +1971,7 @@ skolemiseUnboundMetaTyVar skol_info tv ; return final_tv } where check_empty tv -- [Sept 04] Check for non-empty. - = when debugIsOn $ -- See Note [Silly Type Synonym] + = when debugIsOn $ -- See Note [Silly Type Synonyms] do { cts <- readMetaTyVar tv ; case cts of Flexi -> return () diff --git a/compiler/GHC/Tc/Utils/Zonk.hs b/compiler/GHC/Tc/Utils/Zonk.hs index 805d6a483d..436543b095 100644 --- a/compiler/GHC/Tc/Utils/Zonk.hs +++ b/compiler/GHC/Tc/Utils/Zonk.hs @@ -872,7 +872,7 @@ zonkExpr env expr@(RecordCon { rcon_ext = con_expr, rcon_flds = rbinds }) , rcon_flds = new_rbinds }) } -- Record updates via dot syntax are replaced by desugared expressions --- in the renamer. See Note [Rebindable Syntax and HsExpansion]. This +-- in the renamer. See Note [Rebindable syntax and HsExpansion]. This -- is why we match on 'rupd_flds = Left rbinds' here and panic otherwise. zonkExpr env (RecordUpd { rupd_flds = Left rbinds , rupd_expr = expr diff --git a/compiler/GHC/Types/SourceText.hs b/compiler/GHC/Types/SourceText.hs index 9faba4460b..725637e9d7 100644 --- a/compiler/GHC/Types/SourceText.hs +++ b/compiler/GHC/Types/SourceText.hs @@ -175,7 +175,7 @@ data FractionalLit = FL , fl_neg :: Bool -- See Note [Negative zero] , fl_signi :: Rational -- The significand component of the literal , fl_exp :: Integer -- The exponent component of the literal - , fl_exp_base :: FractionalExponentBase -- See Note [Fractional exponent bases] + , fl_exp_base :: FractionalExponentBase -- See Note [fractional exponent bases] } deriving (Data, Show) -- The Show instance is required for the derived GHC.Parser.Lexer.Token instance when DEBUG is on diff --git a/compiler/GHC/Unit/Info.hs b/compiler/GHC/Unit/Info.hs index b8a238927b..db00a9b91a 100644 --- a/compiler/GHC/Unit/Info.hs +++ b/compiler/GHC/Unit/Info.hs @@ -59,7 +59,7 @@ import Data.List (isPrefixOf, stripPrefix) -- * UnitId: identifier used to generate code (cf 'UnitInfo') -- -- These two identifiers are different for wired-in packages. See Note [About --- Units] in "GHC.Unit" +-- units] in "GHC.Unit" type GenUnitInfo unit = GenericUnitInfo PackageId PackageName unit ModuleName (GenModule (GenUnit unit)) -- | Information about an installed unit (units are identified by their database diff --git a/compiler/GHC/Unit/Module/Deps.hs b/compiler/GHC/Unit/Module/Deps.hs index 3a59703f88..0bab72763b 100644 --- a/compiler/GHC/Unit/Module/Deps.hs +++ b/compiler/GHC/Unit/Module/Deps.hs @@ -420,7 +420,7 @@ hash of the module. The export hash is computed in `GHC.Iface.Recomp.addFingerpr -} {- -Note [Structure of mod_boot_deps] +Note [Structure of dep_boot_deps] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In `-c` mode we always need to know whether to load the normal or boot version of diff --git a/compiler/GHC/Unit/State.hs b/compiler/GHC/Unit/State.hs index 3e74ae9936..cda5c80963 100644 --- a/compiler/GHC/Unit/State.hs +++ b/compiler/GHC/Unit/State.hs @@ -2173,7 +2173,7 @@ instUnitToUnit state iuid = type ShHoleSubst = ModuleNameEnv Module -- | Substitutes holes in a 'Module'. NOT suitable for being called --- directly on a 'nameModule', see Note [Representation of module/name variable]. +-- directly on a 'nameModule', see Note [Representation of module/name variables]. -- @p[A=\<A>]:B@ maps to @p[A=q():A]:B@ with @A=q():A@; -- similarly, @\<A>@ maps to @q():A@. renameHoleModule :: UnitState -> ShHoleSubst -> Module -> Module diff --git a/compiler/GHC/Utils/Monad.hs b/compiler/GHC/Utils/Monad.hs index a6ada16c41..59964b8024 100644 --- a/compiler/GHC/Utils/Monad.hs +++ b/compiler/GHC/Utils/Monad.hs @@ -426,7 +426,7 @@ The magic `inline` function does two things * It helps ensure that 'm' really does inline. -Note that 'inline' evaporates in phase 0. See Note [inlineIdMagic] +Note that 'inline' evaporates in phase 0. See Note [inlineId magic] in GHC.Core.Opt.ConstantFold.match_inline. The INLINE pragma on multiShotM is very important, else the diff --git a/compiler/Language/Haskell/Syntax/Expr.hs b/compiler/Language/Haskell/Syntax/Expr.hs index 049d511318..0abd64d0d8 100644 --- a/compiler/Language/Haskell/Syntax/Expr.hs +++ b/compiler/Language/Haskell/Syntax/Expr.hs @@ -539,7 +539,7 @@ data HsExpr p -- For details on above see Note [exact print annotations] in GHC.Parser.Annotation -- This case only arises when the OverloadedRecordDot langauge - -- extension is enabled. See Note [Record Selectors in the AST]. + -- extension is enabled. See Note [Record selectors in the AST]. | HsGetField { gf_ext :: XGetField p , gf_expr :: LHsExpr p @@ -549,7 +549,7 @@ data HsExpr p -- | Record field selector. e.g. @(.x)@ or @(.x.y)@ -- -- This case only arises when the OverloadedRecordDot langauge - -- extensions is enabled. See Note [Record Selectors in the AST]. + -- extensions is enabled. See Note [Record selectors in the AST]. -- - 'GHC.Parser.Annotation.AnnKeywordId' : 'GHC.Parser.Annotation.AnnOpenP' -- 'GHC.Parser.Annotation.AnnDot', 'GHC.Parser.Annotation.AnnCloseP' diff --git a/compiler/Language/Haskell/Syntax/Extension.hs b/compiler/Language/Haskell/Syntax/Extension.hs index 9c0cc0408b..6a33787d87 100644 --- a/compiler/Language/Haskell/Syntax/Extension.hs +++ b/compiler/Language/Haskell/Syntax/Extension.hs @@ -114,7 +114,7 @@ data DataConCantHappen instance Outputable DataConCantHappen where ppr = dataConCantHappen --- | Eliminate a 'DataConCantHappen'. See Note [Constructor cannot happen]. +-- | Eliminate a 'DataConCantHappen'. See Note [Constructor cannot occur]. dataConCantHappen :: DataConCantHappen -> a dataConCantHappen x = case x of {} diff --git a/libraries/base/GHC/Event/Windows.hsc b/libraries/base/GHC/Event/Windows.hsc index 97a224fdc7..b22fa8d877 100644 --- a/libraries/base/GHC/Event/Windows.hsc +++ b/libraries/base/GHC/Event/Windows.hsc @@ -750,7 +750,7 @@ withOverlappedEx mgr fname h async offset startCB completionCB = do -- otherwise the RTS will lock up until we get a result back. -- In the threaded case it can be beneficial to spin on the haskell -- side versus - -- See also Note [Why use non-waiting getOverlappedResult requests.] + -- See also Note [Why use non-waiting getOverlappedResult requests] res <- FFI.getOverlappedResult fhndl lpol False status <- FFI.overlappedIOStatus lpol case res of diff --git a/libraries/base/GHC/List.hs b/libraries/base/GHC/List.hs index 8dc897c73c..c3800d5d59 100644 --- a/libraries/base/GHC/List.hs +++ b/libraries/base/GHC/List.hs @@ -1446,7 +1446,7 @@ Note [Fusion for zipN/zipWithN] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ We arrange that zip, zip3, etc, and zipWith, zipWit3 etc, are all good consumers for their first (left) argument, and good producers. -Here's how. See Note [Fusion for foldr2] for why it can't fuse its +Here's how. See Note [Fusion for foldrN] for why it can't fuse its second (right) list argument. NB: Zips for larger tuples are in the List module. @@ -1460,7 +1460,7 @@ NB: Zips for larger tuples are in the List module. * To give this rule a chance to fire, we give zip a NOLINLINE[1] pragma (although since zip is recursive it might not need it) -* Now the rules for foldr2 (see Note [Fusion for foldr2]) may fire, +* Now the rules for foldr2 (see Note [Fusion for foldrN]) may fire, or rules that fuse the build-produced output of zip. * If none of these fire, rule "zipList" (active only in phase 1) diff --git a/testsuite/tests/indexed-types/should_compile/T18875.hs b/testsuite/tests/indexed-types/should_compile/T18875.hs index 60fd1cb86a..0121f5ff12 100644 --- a/testsuite/tests/indexed-types/should_compile/T18875.hs +++ b/testsuite/tests/indexed-types/should_compile/T18875.hs @@ -2,7 +2,7 @@ module T18875 where --- This exercises Note [Type variable cycles in Givens] in GHC.Tc.Solver.Canonical +-- This exercises Note [Type variable cycles] in GHC.Tc.Solver.Canonical type family G a b where G (Maybe c) d = d diff --git a/testsuite/tests/linters/notes.stdout b/testsuite/tests/linters/notes.stdout index c7e69aff23..8493d1ea4c 100644 --- a/testsuite/tests/linters/notes.stdout +++ b/testsuite/tests/linters/notes.stdout @@ -1,50 +1,18 @@ -ref compiler/GHC/Builtin/Names.hs:222:15: Note [TyConRepNames for non-wired-in TyCons] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs:3248:21: Note [rts/StgCRun.c : Stack Alignment on X86] -ref compiler/GHC/CmmToC.hs:499:11: Note [Zero-extended sub-word signed results] -ref compiler/GHC/CmmToLlvm/Config.hs:29:11: Note [LLVM Configuration] -ref compiler/GHC/Core.hs:1123:23: Note [Extra args in rule matching] -ref compiler/GHC/Core/Coercion/Axiom.hs:326:7: Note [Compatibility checking] -ref compiler/GHC/Core/Lint.hs:489:11: Note [Checking representation-polymorphic data constructors] -ref compiler/GHC/Core/Lint.hs:1923:0: Note [Rules and join points] -ref compiler/GHC/Core/Make.hs:1033:48: Note [Worker/wrapper for INLINEABLE functions] -ref compiler/GHC/Core/Opt/Arity.hs:1498:22: Note [Check for reflexive casts in eta-expansion] -ref compiler/GHC/Core/Opt/CSE.hs:439:3: Note [Type-let] -ref compiler/GHC/Core/Opt/FloatIn.hs:544:15: Note [extra_fvs (1,2)] -ref compiler/GHC/Core/Opt/OccurAnal.hs:344:28: Note [Rules for imported functions] -ref compiler/GHC/Core/Opt/OccurAnal.hs:576:40: Note [Self-recursive rules] -ref compiler/GHC/Core/Opt/OccurAnal.hs:582:0: Note [Rules and loop breakers] +ref compiler/GHC/Core/Coercion/Axiom.hs:458:2: Note [RoughMap and rm_empty] ref compiler/GHC/Core/Opt/OccurAnal.hs:851:15: Note [Loop breaking] -ref compiler/GHC/Core/Opt/OccurAnal.hs:1738:17: Note [Eta-expansion inside stable unfoldings] -ref compiler/GHC/Core/Opt/Pipeline.hs:624:3: Note [Simplifying the left-hand side of a RULE] -ref compiler/GHC/Core/Opt/Pipeline.hs:937:63: Note [Rules and indirect-zapping] -ref compiler/GHC/Core/Opt/Pipeline.hs:999:31: Note [Messing up the exported Id's IdInfo] -ref compiler/GHC/Core/Opt/Pipeline.hs:1008:7: Note [Messing up the exported Id's IdInfo] ref compiler/GHC/Core/Opt/SetLevels.hs:1598:30: Note [Top level scope] -ref compiler/GHC/Core/Opt/Simplify.hs:672:56: Note [Wrapper NoUserInline] -ref compiler/GHC/Core/Opt/Simplify.hs:2090:33: Note [RULEs apply to simplified arguments] ref compiler/GHC/Core/Opt/Simplify.hs:2618:13: Note [Case binder next] ref compiler/GHC/Core/Opt/Simplify.hs:3239:0: Note [Suppressing binder-swaps on linear case] ref compiler/GHC/Core/Opt/Simplify.hs:3767:8: Note [Lambda-bound unfoldings] ref compiler/GHC/Core/Opt/Simplify.hs:4123:33: Note [Do not eta-expand trivial expressions] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs:133:39: Note [The hole type in ApplyToTy/Val] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs:141:41: Note [The hole type in ApplyToTy/Val] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs:456:59: Note [The hole type in ApplyToTy/Val] ref compiler/GHC/Core/Opt/Simplify/Utils.hs:1225:37: Note [Gentle mode] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs:1624:38: Note [Eta-expanding lambdas] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs:2195:2: Note [Merge nested cases] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs:2196:2: Note [Eliminate identity case] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs:2197:2: Note [Scrutinee constant folding] ref compiler/GHC/Core/Opt/Specialise.hs:1593:28: Note [Arity decrease] -ref compiler/GHC/Core/Rules.hs:885:7: Note [Coercion argument] -ref compiler/GHC/Core/Rules.hs:972:52: Note [Eta reduction in the target] -ref compiler/GHC/Core/Rules.hs:1031:7: Note [Eta reduction in the target] +ref compiler/GHC/Core/RoughMap.hs:183:35: Note [RoughMatch and beta reduction] ref compiler/GHC/Core/Subst.hs:100:60: Note [Apply once] ref compiler/GHC/Core/Subst.hs:111:16: Note [Extending the TCvSubst] ref compiler/GHC/Core/TyCo/FVs.hs:289:7: Note [Free variables of Coercions] ref compiler/GHC/Core/TyCo/Ppr.hs:71:23: Note [IfaceType and pretty-printing] ref compiler/GHC/Core/TyCo/Rep.hs:1711:31: Note [What prevents a constraint from floating] -ref compiler/GHC/Core/TyCo/Subst.hs:116:15: Note [Extending the TvSubstEnv] -ref compiler/GHC/Core/TyCo/Subst.hs:261:16: Note [Extending the TvSubstEnv] ref compiler/GHC/Core/TyCo/Subst.hs:784:15: Note [Extending the TCvSubst] ref compiler/GHC/Core/TyCo/Subst.hs:1001:15: Note [Extending the TCvSubst] ref compiler/GHC/Core/TyCon.hs:961:35: Note [Promoted GADT data construtors] @@ -52,13 +20,11 @@ ref compiler/GHC/Core/TyCon.hs:2442:62: Note [Sharing nullary TyCons] ref compiler/GHC/Core/Unfold.hs:1171:23: Note [INLINE for small functions (3)] ref compiler/GHC/Core/Unfold.hs:1242:50: Note [Unfold info lazy contexts] ref compiler/GHC/Core/Unfold/Make.hs:157:34: Note [DFunUnfoldings] -ref compiler/GHC/Core/Unify.hs:561:16: Note [Unification result] -ref compiler/GHC/Core/Unify.hs:1407:9: Note [INLINE pragmas and (>>)] +ref compiler/GHC/Core/Unify.hs:544:16: Note [Unification result] +ref compiler/GHC/Core/Unify.hs:1390:9: Note [INLINE pragmas and (>>)] ref compiler/GHC/Core/Utils.hs:944:40: Note [ _ -> [con1] ref compiler/GHC/CoreToStg.hs:460:15: Note [Nullary unboxed tuple] ref compiler/GHC/Driver/Main.hs:1551:34: Note [simpleTidyPgm - mkBootModDetailsTc] -ref compiler/GHC/Driver/Session.hs:452:33: Note [LLVM Configuration] -ref compiler/GHC/Driver/Session.hs:776:9: Note [LLVM Configuration] ref compiler/GHC/Driver/Session.hs:1949:36: Note [GHC.Driver.Main . Safe Haskell Inference] ref compiler/GHC/Driver/Session.hs:3910:49: Note [Eta-reduction in -O0] ref compiler/GHC/Hs/Extension.hs:140:5: Note [Strict argument type constraints] @@ -70,16 +36,11 @@ ref compiler/GHC/HsToCore/Binds.hs:942:24: Note [Free dictionaries] ref compiler/GHC/HsToCore/Binds.hs:999:34: Note [Dead spec binders] ref compiler/GHC/HsToCore/Docs.hs:126:70: Note [1] ref compiler/GHC/HsToCore/Docs.hs:130:0: Note [1] -ref compiler/GHC/HsToCore/Expr.hs:1045:22: Note [Checking representation-polymorphic data constructors] -ref compiler/GHC/HsToCore/Pmc/Desugar.hs:77:7: Note [Order of guards matter] ref compiler/GHC/HsToCore/Pmc/Solver.hs:853:20: Note [COMPLETE sets on data families] ref compiler/GHC/HsToCore/Types.hs:61:13: Note [Generating fresh names for FFI wrappers] -ref compiler/GHC/HsToCore/Utils.hs:186:9: Note [MatchIds] ref compiler/GHC/HsToCore/Utils.hs:939:62: Note [Don't CPR join points] ref compiler/GHC/Iface/Syntax.hs:705:0: Note [Minimal complete definition] ref compiler/GHC/Iface/Syntax.hs:765:44: Note [Minimal complete definition] -ref compiler/GHC/Iface/Type.hs-boot:8:7: Note [Depend on GHC.Integer] -ref compiler/GHC/Linker/Types.hs:128:30: Note [Grant plan for static forms] ref compiler/GHC/Parser/Lexer.x:185:7: Note [Lexing NumericUnderscores extension] ref compiler/GHC/Parser/Lexer.x:502:3: Note [Lexing NumericUnderscores extension] ref compiler/GHC/Rename/Expr.hs:2013:9: Note [ApplicativeDo and strict patterns] @@ -87,61 +48,46 @@ ref compiler/GHC/Rename/Expr.hs:2046:12: Note [ApplicativeDo and refutabl ref compiler/GHC/Rename/Expr.hs:2130:18: Note [ApplicativeDo and strict patterns] ref compiler/GHC/Rename/Expr.hs:2148:0: Note [ApplicativeDo and strict patterns] ref compiler/GHC/Rename/Expr.hs:2203:0: Note [ApplicativeDo and refutable patterns] -ref compiler/GHC/Rename/HsType.hs:964:40: Note [CUSKs: Complete user-supplied kind signatures] ref compiler/GHC/Rename/Pat.hs:888:29: Note [Disambiguating record fields] ref compiler/GHC/Rename/Splice.hs:450:27: Note [Splices] -ref compiler/GHC/Rename/Unbound.hs:373:7: Note [Related name spaces] -ref compiler/GHC/Runtime/Eval.hs:995:2: Note [Querying instances for a type] +ref compiler/GHC/Runtime/Eval.hs:996:2: Note [Querying instances for a type] ref compiler/GHC/Runtime/Interpreter.hs:198:30: Note [uninterruptibleMask_] ref compiler/GHC/StgToCmm.hs:107:18: Note [codegen-split-init] ref compiler/GHC/StgToCmm.hs:110:18: Note [pipeline-split-init] -ref compiler/GHC/StgToCmm/DataCon.hs:230:4: Note [CHARLIKE and INTLIKE closures.] ref compiler/GHC/StgToCmm/Expr.hs:491:4: Note [case on bool] -ref compiler/GHC/StgToCmm/Expr.hs:541:42: Note [dataToTag#] ref compiler/GHC/StgToCmm/Expr.hs:751:3: Note [alg-alt heap check] -ref compiler/GHC/StgToCmm/Foreign.hs:177:53: Note [lower safe foreign calls] -ref compiler/GHC/Tc/Deriv/Utils.hs:628:9: Note [Newtype deriving and unused constructors] ref compiler/GHC/Tc/Errors.hs:180:13: Note [Fail fast on kind errors] ref compiler/GHC/Tc/Errors.hs:2016:0: Note [Highlighting ambiguous type variables] -ref compiler/GHC/Tc/Errors/Hole.hs:207:57: Note [Relevant Constraints] -ref compiler/GHC/Tc/Errors/Hole.hs:985:24: Note [Speeding up valid-hole fits] ref compiler/GHC/Tc/Errors/Ppr.hs:1760:11: Note [Highlighting ambiguous type variables] -ref compiler/GHC/Tc/Errors/Types.hs:128:37: Note [Migrating TcM messages] ref compiler/GHC/Tc/Gen/Arrow.hs:435:29: Note [RecStmt] ref compiler/GHC/Tc/Gen/Bind.hs:1397:19: Note [Existentials in pattern bindings] ref compiler/GHC/Tc/Gen/Export.hs:187:15: Note [Modules without a module header] ref compiler/GHC/Tc/Gen/Export.hs:418:0: Note [Modules without a module header] ref compiler/GHC/Tc/Gen/Export.hs:576:7: Note [Typing Pattern Synonym Exports] ref compiler/GHC/Tc/Gen/Export.hs:615:16: Note [Types of TyCon] -ref compiler/GHC/Tc/Gen/Expr.hs:671:24: Note [Disambiguating record fields] -ref compiler/GHC/Tc/Gen/Expr.hs:688:15: Note [Mixed Record Selectors] -ref compiler/GHC/Tc/Gen/Expr.hs:1196:7: Note [Disambiguating record fields] -ref compiler/GHC/Tc/Gen/Expr.hs:1299:11: Note [Deprecating ambiguous fields] +ref compiler/GHC/Tc/Gen/Expr.hs:670:24: Note [Disambiguating record fields] +ref compiler/GHC/Tc/Gen/Expr.hs:687:15: Note [Mixed Record Selectors] +ref compiler/GHC/Tc/Gen/Expr.hs:1195:7: Note [Disambiguating record fields] +ref compiler/GHC/Tc/Gen/Expr.hs:1298:11: Note [Deprecating ambiguous fields] ref compiler/GHC/Tc/Gen/Foreign.hs:149:26: Note [Expanding newtypes] ref compiler/GHC/Tc/Gen/HsType.hs:552:56: Note [Skolem escape prevention] -ref compiler/GHC/Tc/Gen/HsType.hs:1180:39: Note [Body kind of HsForAllTy] ref compiler/GHC/Tc/Gen/HsType.hs:2623:7: Note [Matching a kind sigature with a declaration] -ref compiler/GHC/Tc/Gen/HsType.hs:3152:9: Note [Cloning for type variable binder] ref compiler/GHC/Tc/Gen/Match.hs:553:20: Note [GroupStmt binder map] ref compiler/GHC/Tc/Gen/Match.hs:746:20: Note [GroupStmt binder map] ref compiler/GHC/Tc/Gen/Match.hs:1011:0: Note [typechecking ApplicativeStmt] -ref compiler/GHC/Tc/Gen/Pat.hs:170:20: Note [Typing patterns in pattern bindings] -ref compiler/GHC/Tc/Gen/Pat.hs:477:7: Note [Pattern coercions] -ref compiler/GHC/Tc/Gen/Pat.hs:922:41: Note [Binding when lookup up instances] -ref compiler/GHC/Tc/Gen/Pat.hs:1078:7: Note [Matching polytyped patterns] -ref compiler/GHC/Tc/Gen/Pat.hs:1377:16: Note [Pattern coercions] +ref compiler/GHC/Tc/Gen/Pat.hs:169:20: Note [Typing patterns in pattern bindings] +ref compiler/GHC/Tc/Gen/Pat.hs:476:7: Note [Pattern coercions] +ref compiler/GHC/Tc/Gen/Pat.hs:1077:7: Note [Matching polytyped patterns] +ref compiler/GHC/Tc/Gen/Pat.hs:1376:16: Note [Pattern coercions] ref compiler/GHC/Tc/Gen/Sig.hs:78:10: Note [Overview of type signatures] -ref compiler/GHC/Tc/Gen/Sig.hs:412:28: Note [solveEqualities in tcPatSynSig] ref compiler/GHC/Tc/Instance/Family.hs:515:35: Note [Constrained family instances] ref compiler/GHC/Tc/Module.hs:698:15: Note [Extra dependencies from .hs-boot files] +ref compiler/GHC/Tc/Module.hs:1901:19: Note [Root-main id] ref compiler/GHC/Tc/Module.hs:1971:6: Note [Root-main id] ref compiler/GHC/Tc/Solver.hs:2541:36: Note [Kind generalisation and SigTvs] -ref compiler/GHC/Tc/Solver/Canonical.hs:498:50: Note [The superclasses story] ref compiler/GHC/Tc/Solver/Canonical.hs:1228:33: Note [Canonical LHS] -ref compiler/GHC/Tc/Solver/Canonical.hs:1394:30: Note [Do not decompose given polytype equalities] ref compiler/GHC/Tc/Solver/Interact.hs:1638:9: Note [No touchables as FunEq RHS] ref compiler/GHC/Tc/Solver/Interact.hs:2292:12: Note [The equality class story] -ref compiler/GHC/Tc/Solver/Monad.hs:1343:21: Note [Speeding up valid-hole fits] ref compiler/GHC/Tc/Solver/Rewrite.hs:1032:7: Note [Stability of rewriting] ref compiler/GHC/Tc/TyCl.hs:627:3: Note [Single function non-recursive binding special-case] ref compiler/GHC/Tc/TyCl.hs:1106:6: Note [Unification variables need fresh Names] @@ -151,8 +97,6 @@ ref compiler/GHC/Tc/TyCl/Instance.hs:947:26: Note [Generalising in tcFamT ref compiler/GHC/Tc/Types.hs:647:17: Note [Generating fresh names for FFI wrappers] ref compiler/GHC/Tc/Types.hs:696:33: Note [Extra dependencies from .hs-boot files] ref compiler/GHC/Tc/Types.hs:1145:28: Note [Don't promote data constructors with non-equality contexts] -ref compiler/GHC/Tc/Types.hs:1172:26: Note [Meaning of IdBindingInfo and ClosedTypeId] -ref compiler/GHC/Tc/Types.hs:1195:9: Note [Meaning of IdBindingInfo and ClosedTypeId] ref compiler/GHC/Tc/Types.hs:1221:36: Note [Bindings with closed types] ref compiler/GHC/Tc/Types.hs:1457:47: Note [Care with plugin imports] ref compiler/GHC/Tc/Types/Constraint.hs:238:34: Note [NonCanonical Semantics] @@ -162,52 +106,39 @@ ref compiler/GHC/Tc/Utils/Env.hs:1128:7: Note [Generating fresh names for ref compiler/GHC/Tc/Utils/Env.hs:1141:0: Note [Generating fresh names for FFI wrappers] ref compiler/GHC/Tc/Utils/Env.hs:1192:7: Note [Placeholder PatSyn kinds] ref compiler/GHC/Tc/Utils/TcMType.hs:793:7: Note [Kind checking for GADTs] -ref compiler/GHC/Tc/Utils/TcMType.hs:1974:33: Note [Silly Type Synonym] ref compiler/GHC/Tc/Utils/TcType.hs:529:7: Note [TyVars and TcTyVars] ref compiler/GHC/Tc/Utils/Unify.hs:1489:7: Note [Unification preconditions, (TYVAR-TV)] -ref compiler/GHC/Tc/Utils/Zonk.hs:875:23: Note [Rebindable Syntax and HsExpansion] ref compiler/GHC/ThToHs.hs:1738:11: Note [Adding parens for splices] ref compiler/GHC/ThToHs.hs:1749:3: Note [Adding parens for splices] ref compiler/GHC/Types/Basic.hs:586:17: Note [Safe Haskell isSafeOverlap] ref compiler/GHC/Types/Basic.hs:1326:7: Note [Activation competition] ref compiler/GHC/Types/Demand.hs:307:25: Note [Preserving Boxity of results is rarely a win] ref compiler/GHC/Types/Demand.hs:1100:4: Note [Use one-shot information] -ref compiler/GHC/Types/Error.hs:348:3: Note [Suppressing Messages] -ref compiler/GHC/Types/Error.hs:383:28: Note [Suppressing Messages] +ref compiler/GHC/Types/Error.hs:358:3: Note [Suppressing Messages] +ref compiler/GHC/Types/Error.hs:393:28: Note [Suppressing Messages] ref compiler/GHC/Types/Name/Occurrence.hs:301:4: Note [Unique OccNames from Template Haskell] -ref compiler/GHC/Types/SourceText.hs:178:51: Note [Fractional exponent bases] ref compiler/GHC/Types/Unique.hs:78:25: Note [Uniques-prelude - Uniques for wired-in Prelude things] -ref compiler/GHC/Unit/Info.hs:61:66: Note [About Units] ref compiler/GHC/Unit/Module/Deps.hs:79:13: Note [Structure of dep_boot_mods] -ref compiler/GHC/Unit/State.hs:2176:35: Note [Representation of module/name variable] ref compiler/GHC/Utils/Monad.hs:391:34: Note [multiShotIO] -ref compiler/GHC/Utils/Monad.hs:429:47: Note [inlineIdMagic] ref compiler/Language/Haskell/Syntax/Binds.hs:226:31: Note [fun_id in Match] -ref compiler/Language/Haskell/Syntax/Expr.hs:542:31: Note [Record Selectors in the AST] -ref compiler/Language/Haskell/Syntax/Expr.hs:552:32: Note [Record Selectors in the AST] ref compiler/Language/Haskell/Syntax/Expr.hs:1561:32: Note [Quasi-quote overview] -ref compiler/Language/Haskell/Syntax/Extension.hs:117:42: Note [Constructor cannot happen] ref compiler/Language/Haskell/Syntax/Pat.hs:336:12: Note [Disambiguating record fields] ref configure.ac:212:10: Note [Linking ghc-bin against threaded stage0 RTS] ref docs/core-spec/core-spec.mng:177:6: Note [TyBinders] ref ghc/GHCi/UI.hs:3630:25: Note [ModBreaks.decls] ref ghc/ghc.mk:62:6: Note [Linking ghc-bin against threaded stage0 RTS] ref hadrian/src/Expression.hs:130:30: Note [Linking ghc-bin against threaded stage0 RTS] -ref libraries/base/GHC/Event/Windows.hsc:753:26: Note [Why use non-waiting getOverlappedResult requests.] -ref libraries/base/GHC/List.hs:1449:17: Note [Fusion for foldr2] -ref libraries/base/GHC/List.hs:1463:32: Note [Fusion for foldr2] ref libraries/base/GHC/ST.hs:139:7: Note [Definition of runRW#] -ref testsuite/config/ghc:215:10: Note [WayFlags] +ref testsuite/config/ghc:212:10: Note [WayFlags] ref testsuite/driver/testlib.py:152:10: Note [Why is there no stage1 setup function?] ref testsuite/driver/testlib.py:156:2: Note [Why is there no stage1 setup function?] ref testsuite/mk/boilerplate.mk:259:2: Note [WayFlags] -ref testsuite/tests/indexed-types/should_compile/T18875.hs:5:18: Note [Type variable cycles in Givens] ref testsuite/tests/indexed-types/should_fail/ExtraTcsUntch.hs:30:27: Note [Extra TcS Untouchables] ref testsuite/tests/perf/join_points/join005.hs:19:63: Note [Don't CPR join points] ref testsuite/tests/perf/should_run/all.T:3:6: Note [Solving from instances when interacting Dicts] ref testsuite/tests/polykinds/CuskFam.hs:16:11: Note [Unifying implicit CUSK variables] ref testsuite/tests/simplCore/should_compile/T5776.hs:16:7: Note [Simplifying RULE lhs constraints] -ref testsuite/tests/simplCore/should_compile/simpl018.hs:3:7: Note [Float coercions (unlifted)] +ref testsuite/tests/simplCore/should_compile/simpl018.hs:3:7: Note [Float coercions] ref testsuite/tests/typecheck/should_compile/CbvOverlap.hs:5:26: Note [Type variable cycles in Givens] ref testsuite/tests/typecheck/should_compile/Improvement.hs:10:12: Note [No reduction for Derived class constraints] ref testsuite/tests/typecheck/should_compile/LocalGivenEqs.hs:7:7: Note [When does an implication have given equalities?] @@ -219,9 +150,7 @@ ref testsuite/tests/typecheck/should_compile/tc228.hs:9:7: Note [Inferenc ref testsuite/tests/typecheck/should_compile/tc231.hs:12:16: Note [Important subtlety in oclose] ref testsuite/tests/typecheck/should_fail/UnliftedNewtypesMultiFieldGadt.hs:11:28: Note [Kind-checking the field type] ref testsuite/tests/typecheck/should_fail/tcfail093.hs:13:7: Note [Important subtlety in oclose] -ref utils/ghc-pkg/Main.hs:644:15: Note [Settings File] -ref utils/llvm-targets/gen-data-layout.sh:19:6: Note [LLVM Configuration] -ref utils/notes-util/Notes.hs:30:29: Note [" <> T.unpack x <> "] -ref utils/notes-util/Notes.hs:67:22: Note [...] +ref utils/notes-util/Notes.hs:33:29: Note [" <> T.unpack x <> "] +ref utils/notes-util/Notes.hs:70:22: Note [...] ref validate:413:14: Note [Why is there no stage1 setup function?] diff --git a/testsuite/tests/simplCore/should_compile/simpl018.hs b/testsuite/tests/simplCore/should_compile/simpl018.hs index a0e940fe13..6259c3dc9c 100644 --- a/testsuite/tests/simplCore/should_compile/simpl018.hs +++ b/testsuite/tests/simplCore/should_compile/simpl018.hs @@ -1,6 +1,6 @@ {-# LANGUAGE UnboxedTuples #-} --- See Note [Float coercions (unlifted)] in GHC.Core.Opt.Simplify +-- See Note [Float coercions] in GHC.Core.Opt.Simplify -- This one gave a CoreLint error when compiled optimised -- -- See also #1718, of which this is a simplified version diff --git a/utils/ghc-pkg/Main.hs b/utils/ghc-pkg/Main.hs index c977cb89c0..7bc14094d1 100644 --- a/utils/ghc-pkg/Main.hs +++ b/utils/ghc-pkg/Main.hs @@ -641,7 +641,7 @@ getPkgDatabases verbosity mode use_user use_cache expand_vars my_flags = do case [ f | FlagUserConfig f <- my_flags ] of _ | no_user_db -> return Nothing [] -> do - -- See Note [Settings File] about this file, and why we need GHC to share it with us. + -- See Note [Settings file] about this file, and why we need GHC to share it with us. let settingsFile = top_dir </> "settings" exists_settings_file <- doesFileExist settingsFile targetArchOS <- case exists_settings_file of diff --git a/utils/llvm-targets/gen-data-layout.sh b/utils/llvm-targets/gen-data-layout.sh index a5dfb0bf5a..ed33e6c4f4 100755 --- a/utils/llvm-targets/gen-data-layout.sh +++ b/utils/llvm-targets/gen-data-layout.sh @@ -16,7 +16,7 @@ # Add missing targets to the list below to have them included in # llvm-targets file. # -# See Note [LLVM Configuration] in GHC.SysTools for the whole story regarding LLVM +# See Note [LLVM configuration] in GHC.SysTools for the whole story regarding LLVM # configuration data. # Target sets for which to generate the llvm-targets file |