diff options
28 files changed, 41 insertions, 88 deletions
diff --git a/compiler/GHC/Core/InstEnv.hs b/compiler/GHC/Core/InstEnv.hs index 63dde6f6b5..45ecd4f2b5 100644 --- a/compiler/GHC/Core/InstEnv.hs +++ b/compiler/GHC/Core/InstEnv.hs @@ -965,7 +965,7 @@ lookupInstEnv check_overlap_safe (m:_) | isIncoherent (fst m) -> NoUnifiers _ -> all_unifs - -- NOTE [Safe Haskell isSafeOverlap] + -- Note [Safe Haskell isSafeOverlap] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -- We restrict code compiled in 'Safe' mode from overriding code -- compiled in any other mode. The rationale is that code compiled diff --git a/compiler/GHC/Core/RoughMap.hs b/compiler/GHC/Core/RoughMap.hs index cc64e96149..30145ee544 100644 --- a/compiler/GHC/Core/RoughMap.hs +++ b/compiler/GHC/Core/RoughMap.hs @@ -180,7 +180,7 @@ Where mightMatch is defined like this: mightMatch [] [] = True -- A perfectly sized match might match mightMatch key [] = True -- A shorter lookup key matches everything mightMatch [] (_:_) = True -- If the lookup key is longer, then still might match - -- Note [RoughMatch and beta reduction] + -- Note [RoughMap and beta reduction] mightMatch (k:ks) (lk:lks) = = case (k,lk) of -- Standard case, matching on a specific known TyCon. diff --git a/compiler/GHC/HsToCore/Binds.hs b/compiler/GHC/HsToCore/Binds.hs index 9da2ecbc02..fe7747a4a1 100644 --- a/compiler/GHC/HsToCore/Binds.hs +++ b/compiler/GHC/HsToCore/Binds.hs @@ -847,7 +847,7 @@ decomposeRuleLhs :: DynFlags -> [Var] -> CoreExpr -> Either DsMessage ([Var], Id, [CoreExpr]) -- (decomposeRuleLhs bndrs lhs) takes apart the LHS of a RULE, -- The 'bndrs' are the quantified binders of the rules, but decomposeRuleLhs --- may add some extra dictionary binders (see Note [Free dictionaries]) +-- may add some extra dictionary binders (see Note [Free dictionaries on rule LHS]) -- -- Returns an error message if the LHS isn't of the expected shape -- Note [Decomposing the left-hand side of a RULE] @@ -881,8 +881,8 @@ decomposeRuleLhs dflags orig_bndrs orig_lhs orig_bndr_set = mkVarSet orig_bndrs - -- Add extra tyvar binders: Note [Free tyvars in rule LHS] - -- and extra dict binders: Note [Free dictionaries in rule LHS] + -- Add extra tyvar binders: Note [Free tyvars on rule LHS] + -- and extra dict binders: Note [Free dictionaries on rule LHS] mk_extra_bndrs fn_id args = scopedSort unbound_tvs ++ unbound_dicts where @@ -940,7 +940,7 @@ Note [Decomposing the left-hand side of a RULE] There are several things going on here. * drop_dicts: see Note [Drop dictionary bindings on rule LHS] * simpleOptExpr: see Note [Simplify rule LHS] -* extra_dict_bndrs: see Note [Free dictionaries] +* extra_dict_bndrs: see Note [Free dictionaries on rule LHS] Note [Free tyvars on rule LHS] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -997,7 +997,7 @@ drop_dicts drops dictionary bindings on the LHS where possible. --> f d Reasoning here is that there is only one d:Eq [Int], and so we can quantify over it. That makes 'd' free in the LHS, but that is later - picked up by extra_dict_bndrs (Note [Dead spec binders]). + picked up by extra_dict_bndrs (see Note [Unused spec binders]). NB 1: We can only drop the binding if the RHS doesn't bind one of the orig_bndrs, which we assume occur on RHS. diff --git a/compiler/GHC/HsToCore/Docs.hs b/compiler/GHC/HsToCore/Docs.hs index c4839ae449..7bf49a6c8d 100644 --- a/compiler/GHC/HsToCore/Docs.hs +++ b/compiler/GHC/HsToCore/Docs.hs @@ -273,8 +273,8 @@ mkMaps env instances decls = names _ decl = getMainDeclBinder env decl {- -Note [1]: ---------- +Note [1] +~~~~~~~~ We relate ClsInsts to InstDecls and DerivDecls using the SrcSpans buried inside them. That should work for normal user-written instances (from looking at GHC sources). We can assume that commented instances are diff --git a/compiler/GHC/HsToCore/Utils.hs b/compiler/GHC/HsToCore/Utils.hs index b962b9bd39..be165c80dd 100644 --- a/compiler/GHC/HsToCore/Utils.hs +++ b/compiler/GHC/HsToCore/Utils.hs @@ -933,8 +933,8 @@ Note [Failure thunks and CPR] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ (This note predates join points as formal entities (hence the quotation marks). We can't use actual join points here (see above); if we did, this would also -solve the CPR problem, since join points don't get CPR'd. See Note [Don't CPR -join points] in GHC.Core.Opt.WorkWrap.) +solve the CPR problem, since join points don't get CPR'd. See Note [Don't w/w +join points for CPR] in GHC.Core.Opt.WorkWrap.) When we make a failure point we ensure that it does not look like a thunk. Example: diff --git a/compiler/GHC/Rename/Splice.hs b/compiler/GHC/Rename/Splice.hs index e9eb2c78bb..e67e480d78 100644 --- a/compiler/GHC/Rename/Splice.hs +++ b/compiler/GHC/Rename/Splice.hs @@ -475,7 +475,7 @@ rnSpliceExpr splice run_expr_splice :: HsSplice GhcRn -> RnM (HsExpr GhcRn, FreeVars) run_expr_splice rn_splice | isTypedSplice rn_splice -- Run it later, in the type checker - = do { -- Ugh! See Note [Splices] above + = do { -- Ugh! See Note [Free variables of typed splices] above traceRn "rnSpliceExpr: typed expression splice" empty ; lcl_rdr <- getLocalRdrEnv ; gbl_rdr <- getGlobalRdrEnv diff --git a/compiler/GHC/Runtime/Eval.hs b/compiler/GHC/Runtime/Eval.hs index bf6227737f..e4f4de3fc5 100644 --- a/compiler/GHC/Runtime/Eval.hs +++ b/compiler/GHC/Runtime/Eval.hs @@ -985,7 +985,7 @@ typeKind normalise str = withSession $ \hsc_env -> {- Note [Querying instances for a type] - + ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Here is the implementation of GHC proposal 41. (https://github.com/ghc-proposals/ghc-proposals/blob/master/proposals/0041-ghci-instances.rst) diff --git a/compiler/GHC/Runtime/Interpreter.hs b/compiler/GHC/Runtime/Interpreter.hs index ed906279cc..a61578278f 100644 --- a/compiler/GHC/Runtime/Interpreter.hs +++ b/compiler/GHC/Runtime/Interpreter.hs @@ -200,7 +200,7 @@ interpCmd interp msg = case interpInstance interp of InternalInterp -> run msg -- Just run it directly #endif ExternalInterp c i -> withIServ_ c i $ \iserv -> - uninterruptibleMask_ $ -- Note [uninterruptibleMask_] + uninterruptibleMask_ $ -- Note [uninterruptibleMask_ and interpCmd] iservCall iserv msg diff --git a/compiler/GHC/Tc/Errors.hs b/compiler/GHC/Tc/Errors.hs index 8c46285ad4..237c6fa4a3 100644 --- a/compiler/GHC/Tc/Errors.hs +++ b/compiler/GHC/Tc/Errors.hs @@ -175,7 +175,7 @@ reportUnsolved wanted -- NB: Type-level holes are OK, because there are no bindings. -- See Note [Deferring coercion errors to runtime] -- Used by solveEqualities for kind equalities --- (see Note [Fail fast on kind errors] in "GHC.Tc.Solver") +-- (see Note [Failure in local type signatures] in GHC.Tc.Solver) reportAllUnsolved :: WantedConstraints -> TcM () reportAllUnsolved wanted = do { ev_binds <- newNoTcEvBinds @@ -2237,7 +2237,7 @@ something like Discussion in #9611. Note [Highlighting ambiguous type variables] -~------------------------------------------- +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ When we encounter ambiguous type variables (i.e. type variables that remain metavariables after type inference), we need a few more conditions before we can reason that *ambiguity* prevents constraints diff --git a/compiler/GHC/Tc/Errors/Ppr.hs b/compiler/GHC/Tc/Errors/Ppr.hs index e8cf8ce097..59bde4f0aa 100644 --- a/compiler/GHC/Tc/Errors/Ppr.hs +++ b/compiler/GHC/Tc/Errors/Ppr.hs @@ -2234,7 +2234,7 @@ pprTcSolverReportMsg ctxt@(CEC {cec_encl = implics}) orig = errorItemOrigin item pred = errorItemPred item (clas, tys) = getClassPredTys pred - -- See Note [Highlighting ambiguous type variables] + -- See Note [Highlighting ambiguous type variables] in GHC.Tc.Errors (ambig_kvs, ambig_tvs) = ambigTkvsOfTy pred ambigs = ambig_kvs ++ ambig_tvs has_ambigs = not (null ambigs) diff --git a/compiler/GHC/Tc/Errors/Types.hs b/compiler/GHC/Tc/Errors/Types.hs index b86f1d1506..b1f635325a 100644 --- a/compiler/GHC/Tc/Errors/Types.hs +++ b/compiler/GHC/Tc/Errors/Types.hs @@ -2976,8 +2976,7 @@ data PromotionErr -- in GHC.Tc.Utils.Env. | ConstrainedDataConPE PredType -- Data constructor with a non-equality context - -- See Note [Don't promote data constructors with - -- non-equality contexts] in GHC.Tc.Gen.HsType + -- See Note [Constraints in kinds] in GHC.Core.TyCo.Rep | PatSynPE -- Pattern synonyms -- See Note [Don't promote pattern synonyms] in GHC.Tc.Utils.Env diff --git a/compiler/GHC/Tc/Gen/Arrow.hs b/compiler/GHC/Tc/Gen/Arrow.hs index b404a00b1a..a4eff74ea4 100644 --- a/compiler/GHC/Tc/Gen/Arrow.hs +++ b/compiler/GHC/Tc/Gen/Arrow.hs @@ -435,7 +435,7 @@ tcArrDoStmt env ctxt (RecStmt { recS_stmts = L l stmts, recS_later_ids = later_n -- NB: The rec_ids for the recursive things -- already scope over this part. This binding may shadow -- some of them with polymorphic things with the same Name - -- (see Note [RecStmt] in GHC.Hs.Expr) + -- (see Note [How RecStmt works] in Language.Haskell.Syntax.Expr) ; let rec_ids = takeList rec_names tup_ids ; later_ids <- tcLookupLocalIds later_names diff --git a/compiler/GHC/Tc/Gen/Foreign.hs b/compiler/GHC/Tc/Gen/Foreign.hs index 53e880c0f6..31f47227c8 100644 --- a/compiler/GHC/Tc/Gen/Foreign.hs +++ b/compiler/GHC/Tc/Gen/Foreign.hs @@ -146,7 +146,7 @@ normaliseFfiType' env ty0 = runWriterT $ go Representational initRecTc ty0 | isNewTyCon tc -- Expand newtypes , Just rec_nts' <- checkRecTc rec_nts tc - -- See Note [Expanding newtypes] in GHC.Core.TyCon + -- See Note [Expanding newtypes and products] in GHC.Core.TyCon.RecWalk -- We can't just use isRecursiveTyCon; sometimes recursion is ok: -- newtype T = T (Ptr T) -- Here, we don't reject the type for being recursive. diff --git a/compiler/GHC/Tc/Gen/Match.hs b/compiler/GHC/Tc/Gen/Match.hs index 05d95bf6d2..9c838785ac 100644 --- a/compiler/GHC/Tc/Gen/Match.hs +++ b/compiler/GHC/Tc/Gen/Match.hs @@ -546,7 +546,7 @@ tcLcStmt m_tc ctxt (TransStmt { trS_form = form, trS_stmts = stmts -- Ensure that every old binder of type `b` is linked up with its -- new binder which should have type `n b` - -- See Note [GroupStmt binder map] in GHC.Hs.Expr + -- See Note [TransStmt binder map] in GHC.Hs.Expr n_bndr_ids = zipWith mk_n_bndr n_bndr_names bndr_ids bindersMap' = bndr_ids `zip` n_bndr_ids @@ -739,7 +739,7 @@ tcMcStmt ctxt (TransStmt { trS_stmts = stmts, trS_bndrs = bindersMap -- Ensure that every old binder of type `b` is linked up with its -- new binder which should have type `n b` - -- See Note [GroupStmt binder map] in GHC.Hs.Expr + -- See Note [TransStmt binder map] in GHC.Hs.Expr n_bndr_ids = zipWithEqual "tcMcStmt" mk_n_bndr n_bndr_names bndr_ids bindersMap' = bndr_ids `zip` n_bndr_ids @@ -1005,7 +1005,7 @@ Otherwise the error shows up when checking the rebindable syntax, and the expected/inferred stuff is back to front (see #3613). Note [typechecking ApplicativeStmt] - +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ join ((\pat1 ... patn -> body) <$> e1 <*> ... <*> en) fresh type variables: diff --git a/compiler/GHC/Tc/Gen/Pat.hs b/compiler/GHC/Tc/Gen/Pat.hs index 487b1512ab..45cedcbc8d 100644 --- a/compiler/GHC/Tc/Gen/Pat.hs +++ b/compiler/GHC/Tc/Gen/Pat.hs @@ -1402,12 +1402,8 @@ which applies more generally (not just within 'proc'), as it's a good plan in general to bypass the constraint simplification step entirely when it's not needed. -************************************************************************ -* * - Note [Pattern coercions] -* * -************************************************************************ - +Note [Pattern coercions] +~~~~~~~~~~~~~~~~~~~~~~~~ In principle, these program would be reasonable: f :: (forall a. a->a) -> Int diff --git a/compiler/GHC/Tc/TyCl.hs b/compiler/GHC/Tc/TyCl.hs index 604740c657..52473f3d93 100644 --- a/compiler/GHC/Tc/TyCl.hs +++ b/compiler/GHC/Tc/TyCl.hs @@ -624,7 +624,7 @@ Note [Missed opportunity to retain higher-rank kinds] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In 'kcTyClGroup', there is a missed opportunity to make kind inference work in a few more cases. The idea is analogous -to Note [Single function non-recursive binding special-case]: +to Note [Special case for non-recursive function bindings]: * If we have an SCC with a single decl, which is non-recursive, instead of creating a unification variable representing the @@ -1892,8 +1892,7 @@ DT3 Eta-expansion: Any forall-bound variables and function arguments in a result is produced by processing the return kind in etaExpandAlgTyCon, called in tcDataDefn. - See also Note [TyConBinders for the result kind signatures of a data type] - in GHC.Tc.Gen.HsType. + See also Note [splitTyConKind] in GHC.Tc.Gen.HsType. DT4 Datatype return kind restriction: A data type return kind must end in a type that, after type-synonym expansion, yields `TYPE LiftedRep`. By diff --git a/compiler/GHC/Tc/TyCl/Instance.hs b/compiler/GHC/Tc/TyCl/Instance.hs index 24802a65ea..90951272a2 100644 --- a/compiler/GHC/Tc/TyCl/Instance.hs +++ b/compiler/GHC/Tc/TyCl/Instance.hs @@ -944,7 +944,7 @@ tcDataFamInstHeader mb_clsinfo skol_info fam_tc hs_outer_bndrs fixity -- clearer to duplicate it. Still, if you fix a bug here, -- check there too! - -- See GHC.Tc.TyCl Note [Generalising in tcFamTyPatsGuts] + -- See GHC.Tc.TyCl Note [Generalising in tcTyFamInstEqnGuts] ; dvs <- candidateQTyVarsWithBinders outer_tvs lhs_ty ; qtvs <- quantifyTyVars skol_info TryNotToDefaultNonStandardTyVars dvs ; let final_tvs = scopedSort (qtvs ++ outer_tvs) diff --git a/compiler/GHC/Tc/Types.hs b/compiler/GHC/Tc/Types.hs index f7dd7e7a9a..31e5f8ceed 100644 --- a/compiler/GHC/Tc/Types.hs +++ b/compiler/GHC/Tc/Types.hs @@ -1217,7 +1217,7 @@ ClosedLet means that - The fvs::RhsNames contains the free names of the RHS, excluding Global and ClosedLet ones. - - For the ClosedTypeId field see Note [Bindings with closed types] + - For the ClosedTypeId field see Note [Bindings with closed types: ClosedTypeId] For (static e) to be valid, we need for every 'x' free in 'e', that x's binding is floatable to the top level. Specifically: diff --git a/compiler/GHC/Tc/Utils/Env.hs b/compiler/GHC/Tc/Utils/Env.hs index b116cbbb29..01fde4cd1a 100644 --- a/compiler/GHC/Tc/Utils/Env.hs +++ b/compiler/GHC/Tc/Utils/Env.hs @@ -553,7 +553,7 @@ tcExtendNameTyVarEnv binds thing_inside names = [(name, ATyVar name tv) | (name, tv) <- binds] isTypeClosedLetBndr :: Id -> Bool --- See Note [Bindings with closed types] in GHC.Tc.Types +-- See Note [Bindings with closed types: ClosedTypeId] in GHC.Tc.Types isTypeClosedLetBndr = noFreeVarsOfType . idType tcExtendRecIds :: [(Name, TcId)] -> TcM a -> TcM a @@ -1125,7 +1125,7 @@ mkWrapperName :: (MonadIO m, HasModule m) => IORef (ModuleEnv Int) -> String -> String -> m FastString -- ^ @mkWrapperName ref what nameBase@ -- --- See Note [Generating fresh names for ccall wrapper] for @ref@'s purpose. +-- See Note [Generating fresh names for FFI wrappers] for @ref@'s purpose. mkWrapperName wrapperRef what nameBase = do thisMod <- getModule let pkg = unitString (moduleUnit thisMod) @@ -1187,9 +1187,6 @@ notFound name } wrongThingErr :: String -> TcTyThing -> Name -> TcM a --- It's important that this only calls pprTcTyThingCategory, which in --- turn does not look at the details of the TcTyThing. --- See Note [Placeholder PatSyn kinds] in GHC.Tc.Gen.Bind wrongThingErr expected thing name = let msg = TcRnUnknownMessage $ mkPlainError noHints $ (pprTcTyThingCategory thing <+> quotes (ppr name) <+> diff --git a/compiler/GHC/Tc/Utils/TcMType.hs b/compiler/GHC/Tc/Utils/TcMType.hs index 1206b95da7..21954240d6 100644 --- a/compiler/GHC/Tc/Utils/TcMType.hs +++ b/compiler/GHC/Tc/Utils/TcMType.hs @@ -747,7 +747,7 @@ skolems. They are used in two places: 1. In kind signatures, see GHC.Tc.TyCl Note [Inferring kinds for type declarations] - and Note [Kind checking for GADTs] + and Note [Using TyVarTvs for kind-checking GADTs] 2. In partial type signatures. See GHC.Tc.Types Note [Quantified variables in partial type signatures] diff --git a/compiler/GHC/Tc/Utils/TcType.hs b/compiler/GHC/Tc/Utils/TcType.hs index 63ba3e01c5..bb9f5aa910 100644 --- a/compiler/GHC/Tc/Utils/TcType.hs +++ b/compiler/GHC/Tc/Utils/TcType.hs @@ -588,7 +588,7 @@ we would need to enforce the separation. -} -- A TyVarDetails is inside a TyVar --- See Note [TyVars and TcTyVars] +-- See Note [TyVars and TcTyVars during type checking] data TcTyVarDetails = SkolemTv -- A skolem SkolemInfo diff --git a/compiler/GHC/ThToHs.hs b/compiler/GHC/ThToHs.hs index 931ea20796..a839822e40 100644 --- a/compiler/GHC/ThToHs.hs +++ b/compiler/GHC/ThToHs.hs @@ -1798,8 +1798,9 @@ wrap_tyarg (HsTypeArg l ki) = HsTypeArg l $ parenthesizeHsType appPrec ki wrap_tyarg ta@(HsArgPar {}) = ta -- Already parenthesized -- --------------------------------------------------------------------- --- Note [Adding parens for splices] {- +Note [Adding parens for splices] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The hsSyn representation of parsed source explicitly contains all the original parens, as written in the source. diff --git a/compiler/GHC/Types/Basic.hs b/compiler/GHC/Types/Basic.hs index 92bb8241dd..d562d0937f 100644 --- a/compiler/GHC/Types/Basic.hs +++ b/compiler/GHC/Types/Basic.hs @@ -621,7 +621,7 @@ instance Outputable Origin where -} -- | The semantics allowed for overlapping instances for a particular --- instance. See Note [Safe Haskell isSafeOverlap] (in "GHC.Core.InstEnv") for a +-- instance. See Note [Safe Haskell isSafeOverlap] in GHC.Core.InstEnv for a -- explanation of the `isSafeOverlap` field. -- -- - 'GHC.Parser.Annotation.AnnKeywordId' : diff --git a/compiler/GHC/Types/Demand.hs b/compiler/GHC/Types/Demand.hs index ad890ee31d..54c5ad47ec 100644 --- a/compiler/GHC/Types/Demand.hs +++ b/compiler/GHC/Types/Demand.hs @@ -1362,7 +1362,7 @@ Then argsOneShots returns a [[OneShotInfo]] of [[OneShot,NoOneShotInfo,OneShot], [OneShot]] The occurrence analyser propagates this one-shot infor to the binders \pqr and \xyz; -see Note [Use one-shot information] in "GHC.Core.Opt.OccurAnal". +see Note [Sources of one-shot information] in GHC.Core.Opt.OccurAnal. Note [Boxity in Poly] ~~~~~~~~~~~~~~~~~~~~~ diff --git a/compiler/GHC/Types/Unique.hs b/compiler/GHC/Types/Unique.hs index 25075f47a1..f4538bf579 100644 --- a/compiler/GHC/Types/Unique.hs +++ b/compiler/GHC/Types/Unique.hs @@ -75,7 +75,7 @@ A `Unique` in GHC is a Word-sized value composed of two pieces: The mask is typically an ASCII character. It is typically used to make it easier to distinguish uniques constructed by different parts of the compiler. There is a (potentially incomplete) list of unique masks used given in -GHC.Builtin.Uniques. See Note [Uniques-prelude - Uniques for wired-in Prelude things] +GHC.Builtin.Uniques. See Note [Uniques for wired-in prelude things and known masks] `mkUnique` constructs a `Unique` from its pieces mkUnique :: Char -> Int -> Unique diff --git a/ghc/GHCi/UI.hs b/ghc/GHCi/UI.hs index 8108accaa2..94fc07660b 100644 --- a/ghc/GHCi/UI.hs +++ b/ghc/GHCi/UI.hs @@ -3639,7 +3639,7 @@ completeBreakpoint = wrapCompleter spaces $ \w -> do -- #3000 pure $ zip (repeat str_rdr) $ GHC.nameModule <$> names -- For every top-level identifier in scope, add the bids of the nested - -- declarations. See Note [ModBreaks.decls] in GHC.ByteCode.Types + -- declarations. See Note [Field modBreaks_decls] in GHC.ByteCode.Types addNestedDecls :: GhciMonad m => (String, Module) -> m [String] addNestedDecls (ident, mod) = do (_, decls) <- getModBreak mod diff --git a/testsuite/tests/linters/notes.stdout b/testsuite/tests/linters/notes.stdout index 8540d0c06d..b8822bd476 100644 --- a/testsuite/tests/linters/notes.stdout +++ b/testsuite/tests/linters/notes.stdout @@ -6,73 +6,36 @@ ref compiler/GHC/Core/Opt/Simplify.hs:3239:0: Note [Suppressing binder-sw ref compiler/GHC/Core/Opt/Simplify.hs:3767:8: Note [Lambda-bound unfoldings] ref compiler/GHC/Core/Opt/Simplify/Utils.hs:1225:37: Note [Gentle mode] ref compiler/GHC/Core/Opt/Specialise.hs:1593:28: Note [Arity decrease] -ref compiler/GHC/Core/RoughMap.hs:183:35: Note [RoughMatch and beta reduction] ref compiler/GHC/Core/TyCo/Rep.hs:1711:31: Note [What prevents a constraint from floating] ref compiler/GHC/Driver/Main.hs:1566:34: Note [simpleTidyPgm - mkBootModDetailsTc] ref compiler/GHC/Driver/Session.hs:3916:49: Note [Eta-reduction in -O0] ref compiler/GHC/Hs/Extension.hs:140:5: Note [Strict argument type constraints] ref compiler/GHC/HsToCore/Binds.hs:313:33: Note [AbsBinds wrappers] -ref compiler/GHC/HsToCore/Binds.hs:849:46: Note [Free dictionaries] -ref compiler/GHC/HsToCore/Binds.hs:883:36: Note [Free tyvars in rule LHS] -ref compiler/GHC/HsToCore/Binds.hs:884:35: Note [Free dictionaries in rule LHS] -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/Pmc/Solver.hs:853:20: Note [COMPLETE sets on data families] -ref compiler/GHC/HsToCore/Utils.hs:939:62: Note [Don't CPR join points] 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/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:108:18: Note [codegen-split-init] ref compiler/GHC/StgToCmm.hs:111:18: Note [pipeline-split-init] ref compiler/GHC/StgToCmm/Expr.hs:585:4: Note [case on bool] ref compiler/GHC/StgToCmm/Expr.hs:848:3: Note [alg-alt heap check] -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/Ppr.hs:1760:11: Note [Highlighting ambiguous type variables] -ref compiler/GHC/Tc/Errors/Types.hs:2986:28: Note [Don't promote data constructors with non-equality contexts] -ref compiler/GHC/Tc/Gen/Arrow.hs:435:29: Note [RecStmt] ref compiler/GHC/Tc/Gen/Expr.hs:670:24: Note [Disambiguating record fields] 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:2623:7: Note [Matching a kind sigature with a declaration] -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: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/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/Solver/Canonical.hs:1229:33: Note [Canonical LHS] ref compiler/GHC/Tc/Solver/Interact.hs:1638:9: Note [No touchables as FunEq RHS] 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] -ref compiler/GHC/Tc/TyCl.hs:1895:13: Note [TyConBinders for the result kind signatures of a data type] -ref compiler/GHC/Tc/TyCl/Instance.hs:947:26: Note [Generalising in tcFamTyPatsGuts] ref compiler/GHC/Tc/Types.hs:696:33: Note [Extra dependencies from .hs-boot files] -ref compiler/GHC/Tc/Types.hs:1230:36: Note [Bindings with closed types] ref compiler/GHC/Tc/Types.hs:1466:47: Note [Care with plugin imports] ref compiler/GHC/Tc/Types/Constraint.hs:238:34: Note [NonCanonical Semantics] -ref compiler/GHC/Tc/Utils/Env.hs:556:7: Note [Bindings with closed types] -ref compiler/GHC/Tc/Utils/Env.hs:1128:7: Note [Generating fresh names for ccall wrapper] -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/TcType.hs:529:7: Note [TyVars and TcTyVars] -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:619:17: Note [Safe Haskell isSafeOverlap] 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/Name/Occurrence.hs:301:4: Note [Unique OccNames from Template Haskell] -ref compiler/GHC/Types/Unique.hs:78:25: Note [Uniques-prelude - Uniques for wired-in Prelude things] ref compiler/GHC/Unit/Module/Deps.hs:79:13: Note [Structure of dep_boot_mods] ref compiler/GHC/Utils/Monad.hs:391:34: Note [multiShotIO] ref compiler/Language/Haskell/Syntax/Binds.hs:226:31: Note [fun_id in Match] @@ -80,7 +43,6 @@ ref compiler/Language/Haskell/Syntax/Expr.hs:1561:32: Note [Quasi-quote o 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:3646: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/ST.hs:139:7: Note [Definition of runRW#] @@ -91,7 +53,6 @@ ref testsuite/driver/testlib.py:152:10: Note [Why is there no stage1 setu ref testsuite/driver/testlib.py:156:2: Note [Why is there no stage1 setup function?] ref testsuite/mk/boilerplate.mk:263:2: Note [WayFlags] 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] diff --git a/testsuite/tests/perf/join_points/join005.hs b/testsuite/tests/perf/join_points/join005.hs index 611a3de4ae..4d715c2d87 100644 --- a/testsuite/tests/perf/join_points/join005.hs +++ b/testsuite/tests/perf/join_points/join005.hs @@ -16,8 +16,8 @@ sumOfMultiplesOf p ns It's hard to test for this, but what should happen is that go gets W/W'd and the worker is a join point (else Core Lint will complain). Interestingly, go is *not* CPR'd, because then the worker couldn't be a join point, but once the -simplifier runs, the worker ends up returning Int# anyway. See Note [Don't CPR -join points] in GHC.Core.Opt.WorkWrap. +simplifier runs, the worker ends up returning Int# anyway. See Note [Don't w/w +join points for CPR] in GHC.Core.Opt.WorkWrap. -} main = print $ sumOfMultiplesOf 2 [1..10] |