diff options
| author | Matthew Pickering <matthewtpickering@gmail.com> | 2022-02-02 16:39:20 +0000 |
|---|---|---|
| committer | Marge Bot <ben+marge-bot@smart-cactus.org> | 2022-02-08 05:28:42 -0500 |
| commit | bc5cbce61b57f57cadf5c25fa3e60cf34c3b98ea (patch) | |
| tree | 36350006a6f06895c8b6e74cd785ed18d5584d58 | |
| parent | 1a9438594d6d5280dfe43e4e597dd0380963268d (diff) | |
| download | haskell-bc5cbce61b57f57cadf5c25fa3e60cf34c3b98ea.tar.gz | |
Add notes linter to testsuite
| -rw-r--r-- | .gitlab-ci.yml | 7 | ||||
| -rw-r--r-- | ghc.mk | 2 | ||||
| -rw-r--r-- | hadrian/src/Packages.hs | 5 | ||||
| -rw-r--r-- | hadrian/src/Rules/Test.hs | 39 | ||||
| -rw-r--r-- | hadrian/src/Settings/Default.hs | 1 | ||||
| -rw-r--r-- | testsuite/mk/boilerplate.mk | 4 | ||||
| -rw-r--r-- | testsuite/tests/linters/Makefile | 7 | ||||
| -rw-r--r-- | testsuite/tests/linters/all.T | 20 | ||||
| -rw-r--r-- | testsuite/tests/linters/notes.stdout | 227 | ||||
| -rw-r--r-- | utils/notes-util/Main.hs | 5 | ||||
| -rw-r--r-- | utils/notes-util/Makefile | 17 | ||||
| -rw-r--r-- | utils/notes-util/expected-broken-note-refs | 853 | ||||
| -rw-r--r-- | utils/notes-util/ghc.mk | 18 | ||||
| -rw-r--r-- | utils/notes-util/notes-util.cabal | 2 |
14 files changed, 334 insertions, 873 deletions
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 34bc731138..a7b0c4d4fe 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -194,9 +194,12 @@ ghc-linters: lint-notes: image: "registry.gitlab.haskell.org/ghc/ci-images/linters:$DOCKER_REV" - extends: .lint + extends: .lint-params + variables: + BUILD_FLAVOUR: default script: - - utils/notes-util/check.sh + - .gitlab/ci.sh configure + - .gitlab/ci.sh run_hadrian test --only="notes" dependencies: [] # Run mypy Python typechecker on linter scripts. @@ -545,6 +545,7 @@ utils/ghc-pkg/dist-install/package-data.mk: $(fixed_pkg_prev) utils/hsc2hs/dist-install/package-data.mk: $(fixed_pkg_prev) utils/compare_sizes/dist-install/package-data.mk: $(fixed_pkg_prev) utils/runghc/dist-install/package-data.mk: $(fixed_pkg_prev) +utils/notes-util/dist-install/package-data.mk: $(fixed_pkg_prev) utils/iserv/stage2/package-data.mk: $(fixed_pkg_prev) utils/iserv/stage2_p/package-data.mk: $(fixed_pkg_prev) utils/iserv/stage2_dyn/package-data.mk: $(fixed_pkg_prev) @@ -667,6 +668,7 @@ BUILD_DIRS += utils/hsc2hs BUILD_DIRS += utils/ghc-pkg BUILD_DIRS += utils/testremove BUILD_DIRS += utils/check-ppr +BUILD_DIRS += utils/notes-util BUILD_DIRS += utils/check-exact BUILD_DIRS += utils/count-deps BUILD_DIRS += utils/ghc-cabal diff --git a/hadrian/src/Packages.hs b/hadrian/src/Packages.hs index 2616f097fe..cafea5ff69 100644 --- a/hadrian/src/Packages.hs +++ b/hadrian/src/Packages.hs @@ -9,7 +9,7 @@ module Packages ( hsc2hs, hp2ps, hpc, hpcBin, integerGmp, integerSimple, iserv, iservProxy, libffi, libiserv, mtl, parsec, pretty, primitive, process, remoteIserv, rts, runGhc, stm, templateHaskell, terminfo, text, time, timeout, touchy, - transformers, unlit, unix, win32, xhtml, ghcPackages, isGhcPackage, + transformers, unlit, unix, win32, xhtml, noteLinter, ghcPackages, isGhcPackage, -- * Package information programName, nonHsMainPackage, autogenPath, programPath, timeoutPath, @@ -39,7 +39,7 @@ ghcPackages = , hp2ps, hpc, hpcBin, integerGmp, integerSimple, iserv, libffi, libiserv, mtl , parsec, pretty, process, rts, runGhc, stm, templateHaskell , terminfo, text, time, touchy, transformers, unlit, unix, win32, xhtml - , timeout ] + , timeout, noteLinter ] -- TODO: Optimise by switching to sets of packages. isGhcPackage :: Package -> Bool @@ -107,6 +107,7 @@ unlit = util "unlit" unix = lib "unix" win32 = lib "Win32" xhtml = lib "xhtml" +noteLinter = prg "notes-util" `setPath` "utils/notes-util" -- | Construct a library package, e.g. @array@. lib :: PackageName -> Package diff --git a/hadrian/src/Rules/Test.hs b/hadrian/src/Rules/Test.hs index 27e3cc9176..8ce3daa70b 100644 --- a/hadrian/src/Rules/Test.hs +++ b/hadrian/src/Rules/Test.hs @@ -43,21 +43,31 @@ countDepsSourcePath = "utils/count-deps/Main.hs" countDepsExtra :: Maybe String countDepsExtra = Just "-iutils/count-deps" -checkPrograms :: [(String,FilePath, FilePath, Maybe String, Package)] +noteLinterProgPath, noteLinterSourcePath :: FilePath +noteLinterProgPath = "test/bin/notes-util" <.> exe +noteLinterSourcePath = "utils/notes-util/Main.hs" +noteLinterExtra :: Maybe String +noteLinterExtra = Just "-iutils/notes-util" + +checkPrograms :: [(String,FilePath, FilePath, Maybe String, Package, Stage -> Stage)] checkPrograms = - [ ("test:check-ppr",checkPprProgPath, checkPprSourcePath, checkPprExtra, checkPpr) - , ("test:check-exact",checkExactProgPath, checkExactSourcePath, checkExactExtra, checkExact) - , ("test:count-deps",countDepsProgPath, countDepsSourcePath, countDepsExtra, countDeps) + [ ("test:check-ppr",checkPprProgPath, checkPprSourcePath, checkPprExtra, checkPpr, id) + , ("test:check-exact",checkExactProgPath, checkExactSourcePath, checkExactExtra, checkExact, id) + , ("test:count-deps",countDepsProgPath, countDepsSourcePath, countDepsExtra, countDeps, id) + , ("lint:notes-util", noteLinterProgPath, noteLinterSourcePath, noteLinterExtra, noteLinter, const Stage0) ] -testsuiteDeps :: Rules () -testsuiteDeps = - "test:ghc" ~> do +inTreeOutTree :: (Stage -> Action b) -> Action b -> Action b +inTreeOutTree inTree outTree = do args <- userSetting defaultTestArgs let testCompilerArg = testCompiler args case stageOf testCompilerArg of - Just stg -> needTestsuitePackages stg - Nothing -> return () + Just stg -> inTree stg + Nothing -> outTree + +testsuiteDeps :: Rules () +testsuiteDeps = do + "test:ghc" ~> inTreeOutTree (\stg -> needTestsuitePackages stg) (return ()) ghcConfigPath :: FilePath ghcConfigPath = "test/ghcconfig" @@ -99,7 +109,7 @@ testRules = do -- Rules for building check-ppr, check-exact and -- check-ppr-annotations with the compiler we are going to test -- (in-tree or out-of-tree). - forM_ checkPrograms $ \(name, progPath, sourcePath, mextra, progPkg) -> do + forM_ checkPrograms $ \(name, progPath, sourcePath, mextra, progPkg, mod_stage) -> do name ~> need [root -/- progPath] root -/- progPath %> \path -> do need [ sourcePath ] @@ -109,9 +119,9 @@ testRules = do -- normally, NOT stage3, as there are no rules for stage4 yet case stageOf testGhc of Just stg -> do - fs <- pkgFile stg progPkg + fs <- pkgFile (mod_stage stg) progPkg need [fs] - prog_path <- programPath =<< programContext stg progPkg + prog_path <- programPath =<< programContext (mod_stage stg) progPkg abs_prog_path <- liftIO (IO.canonicalizePath prog_path) createFileLink abs_prog_path path -- otherwise, build it by directly invoking ghc @@ -196,6 +206,7 @@ testRules = do setEnv "CHECK_PPR" (top -/- root -/- checkPprProgPath) setEnv "CHECK_EXACT" (top -/- root -/- checkExactProgPath) setEnv "COUNT_DEPS" (top -/- root -/- countDepsProgPath) + setEnv "NOTES_UTIL" (top -/- root -/- noteLinterProgPath) -- This lets us bypass the need to generate a config -- through Make, which happens in testsuite/mk/boilerplate.mk @@ -220,9 +231,9 @@ isOkToBuild :: TestArgs -> String -> Bool isOkToBuild args target = stageOf (testCompiler args) `elem` [Just Stage1, Just Stage2] || testHasInTreeFiles args - || target `elem` map fst5 checkPrograms + || target `elem` map fst6 checkPrograms where - fst5 (a,_,_,_,_) = a + fst6 (a,_,_,_,_, _) = a -- | Build the timeout program. -- See: https://github.com/ghc/ghc/blob/master/testsuite/timeout/Makefile#L23 diff --git a/hadrian/src/Settings/Default.hs b/hadrian/src/Settings/Default.hs index 1ce66c3534..36a1ed0d8e 100644 --- a/hadrian/src/Settings/Default.hs +++ b/hadrian/src/Settings/Default.hs @@ -86,6 +86,7 @@ stage0Packages = do , text , transformers , unlit + , noteLinter ] ++ [ terminfo | not windowsHost, not cross ] ++ [ timeout | windowsHost ] diff --git a/testsuite/mk/boilerplate.mk b/testsuite/mk/boilerplate.mk index c3be669636..9fc9b36e23 100644 --- a/testsuite/mk/boilerplate.mk +++ b/testsuite/mk/boilerplate.mk @@ -231,6 +231,10 @@ ifeq "$(COUNT_DEPS)" "" COUNT_DEPS := $(abspath $(TOP)/../inplace/bin/count-deps) endif +ifeq "$(NOTES_UTIL)" "" +NOTES_UTIL := $(abspath $(TOP)/../inplace/bin/notes-util) +endif + # ----------------------------------------------------------------------------- # configuration of TEST_HC diff --git a/testsuite/tests/linters/Makefile b/testsuite/tests/linters/Makefile index aeaef050e1..559d0bba3e 100644 --- a/testsuite/tests/linters/Makefile +++ b/testsuite/tests/linters/Makefile @@ -1,4 +1,11 @@ TOP=../.. +ifeq "$(NOTES_UTIL)" "" +NOTES_UTIL := $(abspath $(TOP)/../inplace/bin/notes-util) +endif + uniques: python3 checkUniques/check-uniques.py $(TOP)/.. + +notes: + (cd $(TOP)/.. && $(NOTES_UTIL) broken-refs) diff --git a/testsuite/tests/linters/all.T b/testsuite/tests/linters/all.T index b4cc4bb8b3..ef3ea5441f 100644 --- a/testsuite/tests/linters/all.T +++ b/testsuite/tests/linters/all.T @@ -1 +1,21 @@ test('uniques', [no_deps, extra_files(["checkUniques"])], makefile_test, ['uniques']) + +def normalise_nos(s): + return re.sub(r':\d+:\d+','<line>:<no>', s) + +# Check that ls-files works and returns files from the source tree. +# We just check that "hie.yaml" is there because it's top-level (dont have have to deal with +# path differences) and quite unique to GHC. +def has_ls_files() -> bool: + try: + files = subprocess.check_output(['git', 'ls-files']).splitlines() + print (b"hie.yaml" in files) + return b"hie.yaml" in files + except subprocess.CalledProcessError: + return False + + +test('notes', [no_deps if has_ls_files() else skip + , req_hadrian_deps(["lint:notes-util"]) + , normalise_fun(normalise_nos) ] + , makefile_test, ['notes']) diff --git a/testsuite/tests/linters/notes.stdout b/testsuite/tests/linters/notes.stdout new file mode 100644 index 0000000000..c7e69aff23 --- /dev/null +++ b/testsuite/tests/linters/notes.stdout @@ -0,0 +1,227 @@ +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/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/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] +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/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] +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/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] +ref compiler/GHC/Rename/Expr.hs:2046:12: Note [ApplicativeDo and refutable patterns] +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/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/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/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: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] +ref compiler/GHC/Tc/TyCl.hs:1895:13: Note [TyConBinders for the result kind signatures of a data type] +ref compiler/GHC/Tc/TyCl.hs:4366:16: Note [rejigCon and c.f. Note [Check role annotations in a second pass] +ref compiler/GHC/Tc/TyCl/Instance.hs:947:26: Note [Generalising in tcFamTyPatsGuts] +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] +ref compiler/GHC/Tc/Utils/Concrete.hs:246:2: Note [Concrete and Concrete#] +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: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/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/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/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?] +ref testsuite/tests/typecheck/should_compile/LocalGivenEqs.hs:21:43: Note [Type variable cycles in Givens] +ref testsuite/tests/typecheck/should_compile/LocalGivenEqs2.hs:4:6: Note [When does an implication have given equalities?] +ref testsuite/tests/typecheck/should_compile/T9117.hs:3:12: Note [Order of Coercible Instances] +ref testsuite/tests/typecheck/should_compile/tc200.hs:5:7: Note [Multiple instantiation] +ref testsuite/tests/typecheck/should_compile/tc228.hs:9:7: Note [Inference and implication constraints] +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 validate:413:14: Note [Why is there no stage1 setup function?] + diff --git a/utils/notes-util/Main.hs b/utils/notes-util/Main.hs index d685001d1c..ceaf4f9b04 100644 --- a/utils/notes-util/Main.hs +++ b/utils/notes-util/Main.hs @@ -44,8 +44,11 @@ main = do files <- lines <$> readFile respFile return (parseMode mode, files) [mode] -> do + let excludeList = + [ "testsuite/tests/linters/notes.stdout" + , "utils/notes-util/test" ] files <- lines <$> readProcess "git" ["ls-tree", "--name-only", "-r", "HEAD"] "" - return (parseMode mode, files) + return (parseMode mode, filter (`notElem` excludeList) files) _ -> usage case mode of diff --git a/utils/notes-util/Makefile b/utils/notes-util/Makefile new file mode 100644 index 0000000000..176527a3c7 --- /dev/null +++ b/utils/notes-util/Makefile @@ -0,0 +1,17 @@ +# ----------------------------------------------------------------------------- +# +# (c) 2009 The University of Glasgow +# +# This file is part of the GHC build system. +# +# To understand how the build system works and how to modify it, see +# https://gitlab.haskell.org/ghc/ghc/wikis/building/architecture +# https://gitlab.haskell.org/ghc/ghc/wikis/building/modifying +# +# ----------------------------------------------------------------------------- + +dir = utils/notes-util +TOP = ../.. +include $(TOP)/mk/sub-makefile.mk + +FAST_MAKE_OPTS += stage=none diff --git a/utils/notes-util/expected-broken-note-refs b/utils/notes-util/expected-broken-note-refs deleted file mode 100644 index c0c291f06b..0000000000 --- a/utils/notes-util/expected-broken-note-refs +++ /dev/null @@ -1,853 +0,0 @@ -ref .mailmap: Note [usrbincc] -ref .mailmap: Note [geoffw] -ref .mailmap: Note [zhuang] -ref .mailmap: Note [uid245] -ref .mailmap: Note [geoffw] -ref .mailmap: Note [uid245] -ref .mailmap: Note [usrbincc] -ref .mailmap: Note [zhuang] -ref Makefile: Note [install-strip] -ref Makefile: Note [install-strip] -ref Makefile: Note [install-strip] -ref Makefile: Note [validate and testsuite speed] -ref bindisttest/install: Note [Spaces in TEST_HC] -ref compiler/CodeGen.Platform.h: Note [esi/edi/ebp not allocatable] -ref compiler/CodeGen.Platform.h: Note [esi/edi/ebp not allocatable] -ref compiler/GHC/Builtin/Names.hs: Note [TyConRepNames for non-wired-in TyCons] -ref compiler/GHC/ByteCode/Asm.hs: Note [GHCi tuple layout] -ref compiler/GHC/ByteCode/Types.hs: Note [Syncing breakpoint info] -ref compiler/GHC/Cmm/CLabel.hs: Note [Proc-point local block entry-point] -ref compiler/GHC/Cmm/CLabel.hs: Note [Proc-point local block entry-point] -ref compiler/GHC/Cmm/CLabel.hs: Note [Proc-point local block entry-point] -ref compiler/GHC/Cmm/CLabel.hs: Note [.LCTOC1 in PPC PIC code] -ref compiler/GHC/Cmm/Dataflow.hs: Note [Backward vs forward analysis] -ref compiler/GHC/Cmm/Dataflow.hs: Note [Backward vs forward analysis] -ref compiler/GHC/Cmm/Dataflow.hs: Note [No old fact] -ref compiler/GHC/Cmm/Dataflow.hs: Note [No old fact] -ref compiler/GHC/Cmm/DebugBlock.hs: Note [Splitting DebugBlocks] -ref compiler/GHC/Cmm/Expr.hs: Note [Continuation BlockId] -ref compiler/GHC/Cmm/Expr.hs: Note [Continuation BlockId] -ref compiler/GHC/Cmm/Expr.hs: Note [Overlapping global registers] -ref compiler/GHC/Cmm/Expr.hs: Note [GHCi tuple layout] -ref compiler/GHC/Cmm/Graph.hs: Note [Width of parameters] -ref compiler/GHC/Cmm/Graph.hs: Note [Width of parameters] -ref compiler/GHC/Cmm/Graph.hs: Note [Width of parameters] -ref compiler/GHC/Cmm/Graph.hs: Note [Width of parameters] -ref compiler/GHC/Cmm/Info/Build.hs: Note [STATIC_LINK fields] -ref compiler/GHC/Cmm/Info/Build.hs: Note [STATIC_LINK fields] -ref compiler/GHC/Cmm/Info/Build.hs: Note [recursive SRTs] -ref compiler/GHC/Cmm/Info/Build.hs: Note [recursive SRTs] -ref compiler/GHC/Cmm/Info/Build.hs: Note [recursive SRTs] -ref compiler/GHC/Cmm/Info/Build.hs: Note [recursive SRTs] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [Stack Layout] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [Two pass approach] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [Two pass approach] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [diamond proc point] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [diamond proc point] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [SP old/young offsets] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [SP old/young offsets] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [Lower safe foreign calls] -ref compiler/GHC/Cmm/LayoutStack.hs: Note [safe foreign call convention] -ref compiler/GHC/Cmm/Node.hs: Note [CmmTick scoping details] -ref compiler/GHC/Cmm/Node.hs: Note [Continuation BlockIds] -ref compiler/GHC/Cmm/Node.hs: Note [CmmTick scoping details] -ref compiler/GHC/Cmm/Parser.y: Note [Syntax of .cmm files] -ref compiler/GHC/Cmm/Pipeline.hs: Note [unreachable blocks] -ref compiler/GHC/Cmm/Pipeline.hs: Note [inconsistent-pic-reg] -ref compiler/GHC/Cmm/Pipeline.hs: Note [unreachable blocks] -ref compiler/GHC/Cmm/ProcPoint.hs: Note [No simple dataflow] -ref compiler/GHC/Cmm/ProcPoint.hs: Note [Continuation BlockIds] -ref compiler/GHC/Cmm/ProcPoint.hs: Note [Direct reachability] -ref compiler/GHC/Cmm/ProcPoint.hs: Note [No simple dataflow] -ref compiler/GHC/Cmm/Sink.hs: Note [Keeping assignemnts mentioned in skipped RHSs] -ref compiler/GHC/Cmm/Sink.hs: Note [Keeping assignemnts mentioned in skipped RHSs] -ref compiler/GHC/Cmm/Sink.hs: Note [improveConditional] -ref compiler/GHC/Cmm/Sink.hs: Note [Lower safe foreign calls] -ref compiler/GHC/Cmm/Utils.hs: Note [Overlapping global registers] -ref compiler/GHC/CmmToAsm/AArch64/CodeGen.hs: Note [General layout of an NCG] -ref compiler/GHC/CmmToAsm/AArch64/CodeGen.hs: Note [CSET] -ref compiler/GHC/CmmToAsm/AArch64/CodeGen.hs: Note [CSET] -ref compiler/GHC/CmmToAsm/AArch64/Ppr.hs: Note [Subsections Via Symbols] -ref compiler/GHC/CmmToAsm/AArch64/Ppr.hs: Note [Always use objects for info tables] -ref compiler/GHC/CmmToAsm/CFG.hs: Note [Inverting Conditional Branches] -ref compiler/GHC/CmmToAsm/CFG.hs: Note [Updating the CFG during shortcutting] -ref compiler/GHC/CmmToAsm/Dwarf.hs: Note [Splitting DebugBlocks] -ref compiler/GHC/CmmToAsm/Dwarf.hs: Note [Splitting DebugBlocks] -ref compiler/GHC/CmmToAsm/Dwarf/Types.hs: Note [Info offset] -ref compiler/GHC/CmmToAsm/PIC.hs: Note [.LCTOC1 in PPC PIC code] -ref compiler/GHC/CmmToAsm/PIC.hs: Note [.LCTOC1 in PPC PIC code] -ref compiler/GHC/CmmToAsm/PPC/CodeGen.hs: Note [Power instruction format] -ref compiler/GHC/CmmToAsm/PPC/CodeGen.hs: Note [Power instruction format] -ref compiler/GHC/CmmToAsm/PPC/CodeGen.hs: Note [Seemingly useless cmp and bne] -ref compiler/GHC/CmmToAsm/PPC/CodeGen.hs: Note [Seemingly useless cmp and bne] -ref compiler/GHC/CmmToAsm/PPC/CodeGen.hs: Note [implicit register in PPC PIC code] -ref compiler/GHC/CmmToAsm/PPC/CodeGen.hs: Note [.LCTOC1 in PPC PIC code] -ref compiler/GHC/CmmToAsm/PPC/CodeGen.hs: Note [implicit register in PPC PIC code] -ref compiler/GHC/CmmToAsm/PPC/Ppr.hs: Note [Subsections Via Symbols] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [SSE Parity Checks] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [DIV/IDIV for bytes] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [SSE Parity Checks] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [SSE Parity Checks] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [DIV/IDIV for bytes] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [DIV/IDIV for bytes] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [rts/StgCRun.c : Stack Alignment on X86] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [rts/StgCRun.c : Stack Alignment on X86] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [SSE Parity Checks] -ref compiler/GHC/CmmToAsm/X86/CodeGen.hs: Note [SSE Parity Checks] -ref compiler/GHC/CmmToAsm/X86/Instr.hs: Note [x86 Floating point precision] -ref compiler/GHC/CmmToAsm/X86/Instr.hs: Note [Windows stack layout] -ref compiler/GHC/CmmToAsm/X86/Instr.hs: Note [Windows stack allocations] -ref compiler/GHC/CmmToAsm/X86/Instr.hs: Note [Windows stack layout] -ref compiler/GHC/CmmToAsm/X86/Instr.hs: Note [extra spill slots] -ref compiler/GHC/CmmToAsm/X86/Ppr.hs: Note [Subsections Via Symbols] -ref compiler/GHC/CmmToAsm/X86/Ppr.hs: Note [Subsections Via Symbols] -ref compiler/GHC/CmmToC.hs: Note [StgWord alignment] -ref compiler/GHC/CmmToC.hs: Note [StgWord alignment] -ref compiler/GHC/CmmToC.hs: Note [Zero-extended sub-word signed results] -ref compiler/GHC/CmmToLlvm/Base.hs: Note [Llvm Forward References] -ref compiler/GHC/CmmToLlvm/Config.hs: Note [LLVM Configuration] -ref compiler/GHC/Core.hs: Note [Extra args in rule matching] -ref compiler/GHC/Core/Coercion.hs: Note [Unused coercion variable in ForAllCo] -ref compiler/GHC/Core/Coercion.hs: Note [Unused coercion variable in ForAllCo] -ref compiler/GHC/Core/Coercion.hs: Note [Unused coercion variable in ForAllCo] -ref compiler/GHC/Core/Coercion.hs: Note [liftCoSubstVarBndr] -ref compiler/GHC/Core/Coercion.hs: Note [liftCoSubstVarBndr] -ref compiler/GHC/Core/Coercion/Axiom.hs: Note [Compatibility checking] -ref compiler/GHC/Core/Lint.hs: Note [Checking representation-polymorphic data constructors] -ref compiler/GHC/Core/Lint.hs: Note [Unused coercion variable in ForAllCo] -ref compiler/GHC/Core/Lint.hs: Note [Rules and join points] -ref compiler/GHC/Core/Lint.hs: Note [Unused coercion variable in ForAllCo] -ref compiler/GHC/Core/Make.hs: Note [Worker/wrapper for INLINEABLE functions] -ref compiler/GHC/Core/Opt/Arity.hs: Note [Expanding newtypes] -ref compiler/GHC/Core/Opt/Arity.hs: Note [Exciting arity] -ref compiler/GHC/Core/Opt/Arity.hs: Note [Dealing with bottom (1)] -ref compiler/GHC/Core/Opt/Arity.hs: Note [Dealing with bottom (2)] -ref compiler/GHC/Core/Opt/Arity.hs: Note [Check for reflexive casts in eta-expansion] -ref compiler/GHC/Core/Opt/Arity.hs: Note [The EtaInfo mechansim] -ref compiler/GHC/Core/Opt/CSE.hs: Note [Type-let] -ref compiler/GHC/Core/Opt/CallArity.hs: Note [Analysis I: The arity analysis] -ref compiler/GHC/Core/Opt/CallArity.hs: Note [Analysis II: The Co-Called analysis] -ref compiler/GHC/Core/Opt/CallArity.hs: Note [Analysing top-level-binds] -ref compiler/GHC/Core/Opt/CallArity.hs: Note [Analysis II: The Co-Called analysis] -ref compiler/GHC/Core/Opt/CallArity.hs: Note [Analysis I: The arity analysis] -ref compiler/GHC/Core/Opt/CallArity.hs: Note [Analysis II: The Co-Called analysis] -ref compiler/GHC/Core/Opt/ConstantFold.hs: Note [negative zero] -ref compiler/GHC/Core/Opt/ConstantFold.hs: Note [negative zero] -ref compiler/GHC/Core/Opt/ConstantFold.hs: Note [negative zero] -ref compiler/GHC/Core/Opt/ConstantFold.hs: Note [dataToTag#] -ref compiler/GHC/Core/Opt/ConstantFold.hs: Note [dataToTag#] -ref compiler/GHC/Core/Opt/FloatIn.hs: Note [extra_fvs (1,2)] -ref compiler/GHC/Core/Opt/FloatIn.hs: Note [extra_fvs (1,2)] -ref compiler/GHC/Core/Opt/LiberateCase.hs: Note [Not bottoming ids] -ref compiler/GHC/Core/Opt/OccurAnal.hs: Note [Rules for imported functions] -ref compiler/GHC/Core/Opt/OccurAnal.hs: Note [Self-recursive rules] -ref compiler/GHC/Core/Opt/OccurAnal.hs: Note [Rules and loop breakers] -ref compiler/GHC/Core/Opt/OccurAnal.hs: Note [Loop breaking] -ref compiler/GHC/Core/Opt/OccurAnal.hs: Note [Eta-expansion inside stable unfoldings] -ref compiler/GHC/Core/Opt/Pipeline.hs: Note [Simplifying the left-hand side of a RULE] -ref compiler/GHC/Core/Opt/Pipeline.hs: Note [Rules and indirect-zapping] -ref compiler/GHC/Core/Opt/Pipeline.hs: Note [Messing up the exported Id's IdInfo] -ref compiler/GHC/Core/Opt/Pipeline.hs: Note [Messing up the exported Id's IdInfo] -ref compiler/GHC/Core/Opt/SetLevels.hs: Note [Top level scope] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [Wrapper NoUserInline] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [case-of-scc-of-case] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [case-of-scc-of-case] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [case-of-scc-of-case] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [zapSubstEnv] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [RULEs apply to simplified arguments] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [zapSubstEnv] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [Case binder next] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [Suppressing binder-swaps on linear case] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [Lambda-bound unfoldings] -ref compiler/GHC/Core/Opt/Simplify.hs: Note [Do not eta-expand trivial expressions] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [The hole type in ApplyToTy/Val] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [The hole type in ApplyToTy/Val] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [RHS of lets] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [The hole type in ApplyToTy/Val] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [Gentle mode] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [Simplfying rules] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [Eta-expanding lambdas] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [Nerge nested cases] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [Eliminate identity case] -ref compiler/GHC/Core/Opt/Simplify/Utils.hs: Note [Scrutinee constant folding] -ref compiler/GHC/Core/Opt/SpecConstr.hs: Note [ScrutOcc] -ref compiler/GHC/Core/Opt/Specialise.hs: Note [Missed specialization for ClassOps] -ref compiler/GHC/Core/Opt/Specialise.hs: Note [Inline specialisation] -ref compiler/GHC/Core/Opt/Specialise.hs: Note [Arity decrease] -ref compiler/GHC/Core/Opt/WorkWrap.hs: Note [Demand on the Worker] -ref compiler/GHC/Core/Opt/WorkWrap.hs: Note [Wrapper NoUserInline] -ref compiler/GHC/Core/Opt/WorkWrap.hs: Note [About the NameSorts] -ref compiler/GHC/Core/Opt/WorkWrap.hs: Note [About the NameSorts] -ref compiler/GHC/Core/Opt/WorkWrap/Utils.hs: Note [Boxity Analysis] -ref compiler/GHC/Core/Rules.hs: Note [Coercion argument] -ref compiler/GHC/Core/Rules.hs: Note [Eta reduction in the target] -ref compiler/GHC/Core/Rules.hs: Note [Eta reduction in the target] -ref compiler/GHC/Core/Subst.hs: Note [Apply once] -ref compiler/GHC/Core/Subst.hs: Note [Extending the TCvSubst] -ref compiler/GHC/Core/TyCo/FVs.hs: Note [Free variables of Coercions] -ref compiler/GHC/Core/TyCo/FVs.hs: Note [Unused coercion variable in ForAllCo] -ref compiler/GHC/Core/TyCo/Ppr.hs: Note [IfaceType and pretty-printing] -ref compiler/GHC/Core/TyCo/Rep.hs: Note [What prevents a constraint from floating] -ref compiler/GHC/Core/TyCo/Subst.hs: Note [Extending the TCvSubst] -ref compiler/GHC/Core/TyCo/Subst.hs: Note [Extending the TCvSubst] -ref compiler/GHC/Core/TyCon.hs: Note [Promoted GADT data construtors] -ref compiler/GHC/Core/TyCon.hs: Note [Promoted GADT data construtors] -ref compiler/GHC/Core/TyCon.hs: Note [bad unsafe coercion] -ref compiler/GHC/Core/TyCon.hs: Note [The Purely Kinded Invariant] -ref compiler/GHC/Core/TyCon.hs: Note [Sharing nullary TyCons] -ref compiler/GHC/Core/Unfold.hs: Note [RHS of lets] -ref compiler/GHC/Core/Unfold.hs: Note [INLINE for small functions (3)] -ref compiler/GHC/Core/Unfold.hs: Note [Unfold info lazy contexts] -ref compiler/GHC/Core/Unfold/Make.hs: Note [DFunUnfoldings] -ref compiler/GHC/Core/Unify.hs: Note [Unification result] -ref compiler/GHC/Core/Unify.hs: Note [INLINE pragmas and (>>)] -ref compiler/GHC/Core/Utils.hs: Note [ _ -> [con1] -ref compiler/GHC/Core/Utils.hs: Note [Interaction of exprIsCheap and lone variables] -ref compiler/GHC/Core/Utils.hs: Note [exprIsHNF Tick] -ref compiler/GHC/Core/Utils.hs: Note [exprIsHNF Tick] -ref compiler/GHC/Core/Utils.hs: Note [Arity care] -ref compiler/GHC/Core/Utils.hs: Note [Arity care] -ref compiler/GHC/CoreToStg.hs: Note [Nullary unboxed tuple] -ref compiler/GHC/CoreToStg/Prep.hs: Note [CorePrep Overview] -ref compiler/GHC/CoreToStg/Prep.hs: Note [Floating Ticks in CorePrep] -ref compiler/GHC/CoreToStg/Prep.hs: Note [Floating Ticks in CorePrep] -ref compiler/GHC/Data/FastString.hs: Note [Updating the FastString table] -ref compiler/GHC/Data/FastString.hs: Note [Updating the FastString table] -ref compiler/GHC/Driver/CmdLine.hs: Note [Handling errors when parsing flags] -ref compiler/GHC/Driver/CmdLine.hs: Note [Handling errors when parsing commandline flags] -ref compiler/GHC/Driver/Flags.hs: Note [Valid hole fits include] -ref compiler/GHC/Driver/Flags.hs: Note [Print Hexadecimal Literals] -ref compiler/GHC/Driver/Main.hs: Note [simpleTidyPgm - mkBootModDetailsTc] -ref compiler/GHC/Driver/Make.hs: Note [Unused packages] -ref compiler/GHC/Driver/Make.hs: Note [GHC Heap Invariants] -ref compiler/GHC/Driver/Make.hs: Note [GHC Heap Invariants] -ref compiler/GHC/Driver/Pipeline/Execute.hs: Note [Clamping of llc optimizations] -ref compiler/GHC/Driver/Pipeline/Execute.hs: Note [Don't normalise input filenames] -ref compiler/GHC/Driver/Pipeline/Execute.hs: Note [Don't normalise input filenames] -ref compiler/GHC/Driver/Session.hs: Note [LLVM Configuration] -ref compiler/GHC/Driver/Session.hs: Note [LLVM Configuration] -ref compiler/GHC/Driver/Session.hs: Note [Handling errors when parsing commandline flags] -ref compiler/GHC/Driver/Session.hs: Note [GHC.Driver.Main . Safe Haskell Inference] -ref compiler/GHC/Driver/Session.hs: Note [Eta-reduction in -O0] -ref compiler/GHC/Driver/Session.hs: Note [No PIE when linking] -ref compiler/GHC/Hs/Expr.hs: Note [Applicative BodyStmt] -ref compiler/GHC/Hs/Expr.hs: Note [Applicative BodyStmt] -ref compiler/GHC/Hs/Extension.hs: Note [Strict argument type constraints] -ref compiler/GHC/HsToCore/Binds.hs: Note [AbsBinds wrappers] -ref compiler/GHC/HsToCore/Binds.hs: Note [Free dictionaries] -ref compiler/GHC/HsToCore/Binds.hs: Note [Free tyvars in rule LHS] -ref compiler/GHC/HsToCore/Binds.hs: Note [Free dictionaries in rule LHS] -ref compiler/GHC/HsToCore/Binds.hs: Note [Free dictionaries] -ref compiler/GHC/HsToCore/Binds.hs: Note [Dead spec binders] -ref compiler/GHC/HsToCore/Coverage.hs: Note [inline sccs] -ref compiler/GHC/HsToCore/Coverage.hs: Note [inline sccs] -ref compiler/GHC/HsToCore/Coverage.hs: Note [inline sccs] -ref compiler/GHC/HsToCore/Coverage.hs: Note [inline sccs] -ref compiler/GHC/HsToCore/Coverage.hs: Note [freevars] -ref compiler/GHC/HsToCore/Docs.hs: Note [1] -ref compiler/GHC/HsToCore/Docs.hs: Note [1] -ref compiler/GHC/HsToCore/Expr.hs: Note [Checking representation-polymorphic data constructors] -ref compiler/GHC/HsToCore/Expr.hs: Note [NOINLINE someNatVal] -ref compiler/GHC/HsToCore/Match.hs: Note [Empty case expressions] -ref compiler/GHC/HsToCore/Match.hs: Note [Case elimination: lifted case] -ref compiler/GHC/HsToCore/Pmc/Desugar.hs: Note [Order of guards matter] -ref compiler/GHC/HsToCore/Pmc/Solver.hs: Note [COMPLETE sets on data families] -ref compiler/GHC/HsToCore/Pmc/Solver.hs: Note [Pos/Neg invariant] -ref compiler/GHC/HsToCore/Pmc/Solver.hs: Note [Soundness and Completeness] -ref compiler/GHC/HsToCore/Pmc/Solver.hs: Note [Soundness and Completeness] -ref compiler/GHC/HsToCore/Types.hs: Note [Generating fresh names for FFI wrappers] -ref compiler/GHC/HsToCore/Types.hs: Note [Note [Long-distance information] -ref compiler/GHC/HsToCore/Utils.hs: Note [MatchIds] -ref compiler/GHC/HsToCore/Utils.hs: Note [Don't CPR join points] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Updating HieAst for changes in the GHC AST] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Capturing Scopes and other non local information] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Name Remapping] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Name Remapping] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Capturing Scopes and other non local information] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [TyVar Scopes] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Scoping Rules for SigPat] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Updating HieAst for changes in the GHC AST] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Name Remapping] -ref compiler/GHC/Iface/Ext/Ast.hs: Note [Scoping Rules for SigPat] -ref compiler/GHC/Iface/Load.hs: Note [GHC Heap Invariants] -ref compiler/GHC/Iface/Recomp.hs: Note [default method Name] -ref compiler/GHC/Iface/Recomp.hs: Note [default method Name] -ref compiler/GHC/Iface/Recomp.hs: Note [default method Name] -ref compiler/GHC/Iface/Recomp/Flags.hs: Note [path flags and recompilation] -ref compiler/GHC/Iface/Recomp/Flags.hs: Note [path flags and recompilation] -ref compiler/GHC/Iface/Syntax.hs: Note [Minimal complete definition] -ref compiler/GHC/Iface/Syntax.hs: Note [Minimal complete definition] -ref compiler/GHC/Linker/Loader.hs: Note [preload packages] -ref compiler/GHC/Linker/Loader.hs: Note [preload packages] -ref compiler/GHC/Linker/Static.hs: Note [No PIE when linking] -ref compiler/GHC/Linker/Types.hs: Note [Grant plan for static forms] -ref compiler/GHC/Parser/Lexer.x: Note [Lexing NumericUnderscores extension] -ref compiler/GHC/Parser/Lexer.x: Note [Lexing NumericUnderscores extension] -ref compiler/GHC/Rename/Env.hs: Note [ Unbound vs Ambiguous Names ] -ref compiler/GHC/Rename/Env.hs: Note [ Unbound vs Ambiguous Names ] -ref compiler/GHC/Rename/Env.hs: Note [ Unbound vs Ambiguous Names ] -ref compiler/GHC/Rename/Expr.hs: Note [ApplicativeDo] -ref compiler/GHC/Rename/Expr.hs: Note [ApplicativeDo] -ref compiler/GHC/Rename/Expr.hs: Note [ApplicativeDo and strict patterns] -ref compiler/GHC/Rename/Expr.hs: Note [ApplicativeDo and refutable patterns] -ref compiler/GHC/Rename/Expr.hs: Note [ApplicativeDo and strict patterns] -ref compiler/GHC/Rename/Expr.hs: Note [ApplicativeDo and strict patterns] -ref compiler/GHC/Rename/Expr.hs: Note [ApplicativeDo and refutable patterns] -ref compiler/GHC/Rename/HsType.hs: Note [CUSKs: Complete user-supplied kind signatures] -ref compiler/GHC/Rename/Pat.hs: Note [Disambiguating record fields] -ref compiler/GHC/Rename/Splice.hs: Note [RunSplice ThLevel] -ref compiler/GHC/Rename/Splice.hs: Note [Splices] -ref compiler/GHC/Rename/Unbound.hs: Note [Only-quals] -ref compiler/GHC/Rename/Unbound.hs: Note [Only-quals] -ref compiler/GHC/Rename/Unbound.hs: Note [Related name spaces] -ref compiler/GHC/Runtime/Eval.hs: Note [Syncing breakpoint info] -ref compiler/GHC/Runtime/Eval.hs: Note [Syncing breakpoint info] -ref compiler/GHC/Runtime/Eval.hs: Note [Querying instances for a type] -ref compiler/GHC/Runtime/Interpreter.hs: Note [Remote GHCi] -ref compiler/GHC/Runtime/Interpreter.hs: Note [External GHCi pointers] -ref compiler/GHC/Runtime/Interpreter.hs: Note [Remote Template Haskell] -ref compiler/GHC/Runtime/Interpreter.hs: Note [uninterruptibleMask_] -ref compiler/GHC/Runtime/Interpreter.hs: Note [uninterruptibleMask_ and interpCmd] -ref compiler/GHC/Runtime/Interpreter.hs: Note [loadObj and relative paths] -ref compiler/GHC/Runtime/Interpreter.hs: Note [loadObj and relative paths] -ref compiler/GHC/Runtime/Interpreter.hs: Note [loadObj and relative paths] -ref compiler/GHC/Runtime/Interpreter.hs: Note [loadObj and relative paths] -ref compiler/GHC/Runtime/Interpreter.hs: Note [External GHCi pointers] -ref compiler/GHC/Settings/IO.hs: Note [tooldir: How GHC finds mingw on Windows] -ref compiler/GHC/StgToByteCode.hs: Note [generating code for top-level string literal bindings] -ref compiler/GHC/StgToByteCode.hs: Note [generating code for top-level string literal bindings] -ref compiler/GHC/StgToByteCode.hs: Note [GHCi unboxed tuples stack spills] -ref compiler/GHC/StgToByteCode.hs: Note [GHCi tuple layout] -ref compiler/GHC/StgToByteCode.hs: Note [CASEFAIL] -ref compiler/GHC/StgToByteCode.hs: Note [CASEFAIL] -ref compiler/GHC/StgToByteCode.hs: Note [generating code for top-level string literal bindings] -ref compiler/GHC/StgToCmm.hs: Note [codegen-split-init] -ref compiler/GHC/StgToCmm.hs: Note [pipeline-split-init] -ref compiler/GHC/StgToCmm/Bind.hs: Note [cgBind rec] -ref compiler/GHC/StgToCmm/Closure.hs: Note [Evaluating functions with profiling] -ref compiler/GHC/StgToCmm/DataCon.hs: Note [About the NameSorts] -ref compiler/GHC/StgToCmm/DataCon.hs: Note [CHARLIKE and INTLIKE closures.] -ref compiler/GHC/StgToCmm/DataCon.hs: Note [About the NameSorts] -ref compiler/GHC/StgToCmm/Expr.hs: Note [case on bool] -ref compiler/GHC/StgToCmm/Expr.hs: Note [dataToTag#] -ref compiler/GHC/StgToCmm/Expr.hs: Note [alg-alt heap check] -ref compiler/GHC/StgToCmm/Foreign.hs: Note [safe foreign call convention] -ref compiler/GHC/StgToCmm/Foreign.hs: Note [safe foreign call convention] -ref compiler/GHC/StgToCmm/Foreign.hs: Note [lower safe foreign calls] -ref compiler/GHC/StgToCmm/Foreign.hs: Note [safe foreign call convention] -ref compiler/GHC/StgToCmm/Foreign.hs: Note [GHCi tuple layout] -ref compiler/GHC/StgToCmm/Heap.hs: Note [STATIC_LINK fields] -ref compiler/GHC/StgToCmm/Heap.hs: Note [stg_gc arguments] -ref compiler/GHC/StgToCmm/Heap.hs: Note [stg_gc arguments] -ref compiler/GHC/StgToCmm/Layout.hs: Note [avoid intermediate PAPs] -ref compiler/GHC/StgToCmm/Layout.hs: Note [diamond proc point] -ref compiler/GHC/StgToCmm/Layout.hs: Note [avoid intermediate PAPs] -ref compiler/GHC/StgToCmm/Layout.hs: Note [over-saturated calls] -ref compiler/GHC/StgToCmm/Layout.hs: Note [over-saturated calls] -ref compiler/GHC/StgToCmm/Monad.hs: Note [sharing continuations] -ref compiler/GHC/StgToCmm/Monad.hs: Note [sharing continuations] -ref compiler/GHC/SysTools.hs: Note [Windows stack usage] -ref compiler/GHC/SysTools/BaseDir.hs: Note [tooldir: How GHC finds mingw on Windows] -ref compiler/GHC/SysTools/BaseDir.hs: Note [tooldir: How GHC finds mingw on Windows] -ref compiler/GHC/SysTools/Info.hs: Note [Run-time linker info] -ref compiler/GHC/SysTools/Info.hs: Note [ELF needed shared libs] -ref compiler/GHC/SysTools/Info.hs: Note [Windows static libGCC] -ref compiler/GHC/SysTools/Info.hs: Note [Run-time linker info] -ref compiler/GHC/SysTools/Info.hs: Note [ELF needed shared libs] -ref compiler/GHC/SysTools/Info.hs: Note [ELF needed shared libs] -ref compiler/GHC/SysTools/Info.hs: Note [ELF needed shared libs] -ref compiler/GHC/SysTools/Info.hs: Note [Windows stack usage] -ref compiler/GHC/SysTools/Info.hs: Note [Windows static libGCC] -ref compiler/GHC/SysTools/Info.hs: Note [Run-time linker info] -ref compiler/GHC/SysTools/Tasks.hs: Note [Run-time linker info] -ref compiler/GHC/Tc/Deriv/Utils.hs: Note [Newtype deriving and unused constructors] -ref compiler/GHC/Tc/Errors.hs: Note [Fail fast on kind errors] -ref compiler/GHC/Tc/Errors.hs: Note [Highlighting ambiguous type variables] -ref compiler/GHC/Tc/Errors/Hole.hs: Note [Relevant Constraints] -ref compiler/GHC/Tc/Errors/Hole.hs: Note [Speeding up valid-hole fits] -ref compiler/GHC/Tc/Errors/Ppr.hs: Note [Highlighting ambiguous type variables] -ref compiler/GHC/Tc/Errors/Types.hs: Note [Migrating TcM messages] -ref compiler/GHC/Tc/Gen/Bind.hs: Note [Existentials in pattern bindings] -ref compiler/GHC/Tc/Gen/Export.hs: Note [Modules without a module header] -ref compiler/GHC/Tc/Gen/Export.hs: Note [Modules without a module header] -ref compiler/GHC/Tc/Gen/Expr.hs: Note [Disambiguating record fields] -ref compiler/GHC/Tc/Gen/Expr.hs: Note [Disambiguating record fields] -ref compiler/GHC/Tc/Gen/Expr.hs: Note [Deprecating ambiguous fields] -ref compiler/GHC/Tc/Gen/Foreign.hs: Note [Expanding newtypes] -ref compiler/GHC/Tc/Gen/HsType.hs: Note [Skolem escape prevention] -ref compiler/GHC/Tc/Gen/HsType.hs: Note [Body kind of HsForAllTy] -ref compiler/GHC/Tc/Gen/HsType.hs: Note [Matching a kind sigature with a declaration] -ref compiler/GHC/Tc/Gen/HsType.hs: Note [Cloning for type variable binder] -ref compiler/GHC/Tc/Gen/Match.hs: Note [GroupStmt binder map] -ref compiler/GHC/Tc/Gen/Match.hs: Note [GroupStmt binder map] -ref compiler/GHC/Tc/Gen/Match.hs: Note [typechecking ApplicativeStmt] -ref compiler/GHC/Tc/Gen/Pat.hs: Note [Typing patterns in pattern bindings] -ref compiler/GHC/Tc/Gen/Pat.hs: Note [Pattern coercions] -ref compiler/GHC/Tc/Gen/Pat.hs: Note [Binding when lookup up instances] -ref compiler/GHC/Tc/Gen/Pat.hs: Note [Matching polytyped patterns] -ref compiler/GHC/Tc/Gen/Pat.hs: Note [Pattern coercions] -ref compiler/GHC/Tc/Gen/Sig.hs: Note [Overview of type signatures] -ref compiler/GHC/Tc/Gen/Sig.hs: Note [solveEqualities in tcPatSynSig] -ref compiler/GHC/Tc/Gen/Splice.hs: Note [RunSplice ThLevel] -ref compiler/GHC/Tc/Gen/Splice.hs: Note [Remote Template Haskell] -ref compiler/GHC/Tc/Gen/Splice.hs: Note [Remote Template Haskell] -ref compiler/GHC/Tc/Gen/Splice.hs: Note [TH recover with -fexternal-interpreter] -ref compiler/GHC/Tc/Gen/Splice.hs: Note [TH recover with -fexternal-interpreter] -ref compiler/GHC/Tc/Instance/Family.hs: Note [Constrained family instances] -ref compiler/GHC/Tc/Instance/FunDeps.hs: Note [Coverage Condition] -ref compiler/GHC/Tc/Module.hs: Note [Extra dependencies from .hs-boot files] -ref compiler/GHC/Tc/Module.hs: Note [Root-main id] -ref compiler/GHC/Tc/Solver.hs: Note [Kind generalisation and SigTvs] -ref compiler/GHC/Tc/Solver/Canonical.hs: Note [The superclasses story] -ref compiler/GHC/Tc/Solver/Canonical.hs: Note [Canonical LHS] -ref compiler/GHC/Tc/Solver/Canonical.hs: Note [Do not decompose given polytype equalities] -ref compiler/GHC/Tc/Solver/Interact.hs: Note [No touchables as FunEq RHS] -ref compiler/GHC/Tc/Solver/Interact.hs: Note [The improvement story] -ref compiler/GHC/Tc/Solver/Interact.hs: Note [The equality class story] -ref compiler/GHC/Tc/Solver/Monad.hs: Note [Speeding up valid-hole fits] -ref compiler/GHC/Tc/Solver/Rewrite.hs: Note [Stability of rewriting] -ref compiler/GHC/Tc/TyCl.hs: Note [Single function non-recursive binding special-case] -ref compiler/GHC/Tc/TyCl.hs: Note [Unification variables need fresh Names] -ref compiler/GHC/Tc/TyCl.hs: Note [TyConBinders for the result kind signatures of a data type] -ref compiler/GHC/Tc/TyCl.hs: Note [rejigCon and c.f. Note [Check role annotations in a second pass] -ref compiler/GHC/Tc/TyCl/Instance.hs: Note [Generalising in tcFamTyPatsGuts] -ref compiler/GHC/Tc/Types.hs: Note [Generating fresh names for FFI wrappers] -ref compiler/GHC/Tc/Types.hs: Note [Extra dependencies from .hs-boot files] -ref compiler/GHC/Tc/Types.hs: Note [RunSplice ThLevel] -ref compiler/GHC/Tc/Types.hs: Note [RunSplice ThLevel] -ref compiler/GHC/Tc/Types.hs: Note [Don't promote data constructors with non-equality contexts] -ref compiler/GHC/Tc/Types.hs: Note [Meaning of IdBindingInfo and ClosedTypeId] -ref compiler/GHC/Tc/Types.hs: Note [Meaning of IdBindingInfo and ClosedTypeId] -ref compiler/GHC/Tc/Types.hs: Note [Bindings with closed types] -ref compiler/GHC/Tc/Types.hs: Note [Care with plugin imports] -ref compiler/GHC/Tc/Types/Constraint.hs: Note [NonCanonical Semantics] -ref compiler/GHC/Tc/Types/Constraint.hs: Note [The improvement story] -ref compiler/GHC/Tc/Utils/Concrete.hs: Note [Concrete and Concrete#] -ref compiler/GHC/Tc/Utils/Env.hs: Note [Bindings with closed types] -ref compiler/GHC/Tc/Utils/Env.hs: Note [Generating fresh names for ccall wrapper] -ref compiler/GHC/Tc/Utils/Env.hs: Note [Generating fresh names for FFI wrappers] -ref compiler/GHC/Tc/Utils/Env.hs: Note [Placeholder PatSyn kinds] -ref compiler/GHC/Tc/Utils/TcMType.hs: Note [Kind checking for GADTs] -ref compiler/GHC/Tc/Utils/TcType.hs: Note [TyVars and TcTyVars] -ref compiler/GHC/Tc/Utils/Unify.hs: Note [Unification preconditions, (TYVAR-TV)] -ref compiler/GHC/Tc/Utils/Zonk.hs: Note [Rebindable Syntax and HsExpansion] -ref compiler/GHC/ThToHs.hs: Note [Operator association] -ref compiler/GHC/ThToHs.hs: Note [Operator association] -ref compiler/GHC/ThToHs.hs: Note [Operator association] -ref compiler/GHC/ThToHs.hs: Note [Adding parens for splices] -ref compiler/GHC/ThToHs.hs: Note [Adding parens for splices] -ref compiler/GHC/Types/Basic.hs: Note [Safe Haskell isSafeOverlap] -ref compiler/GHC/Types/Basic.hs: Note [Activation competition] -ref compiler/GHC/Types/Demand.hs: Note [Preserving Boxity of results is rarely a win] -ref compiler/GHC/Types/Demand.hs: Note [Use one-shot information] -ref compiler/GHC/Types/Error.hs: Note [Suppressing Messages] -ref compiler/GHC/Types/Error.hs: Note [Suppressing Messages] -ref compiler/GHC/Types/Id/Make.hs: Note [Left folds via right fold] -ref compiler/GHC/Types/Name.hs: Note [About the NameSorts] -ref compiler/GHC/Types/Name.hs: Note [About the NameSorts] -ref compiler/GHC/Types/Name/Occurrence.hs: Note [Data Constructors] -ref compiler/GHC/Types/Name/Occurrence.hs: Note [Unique OccNames from Template Haskell] -ref compiler/GHC/Types/SourceText.hs: Note [Fractional exponent bases] -ref compiler/GHC/Types/Tickish.hs: Note [Tickish passes] -ref compiler/GHC/Types/Tickish.hs: Note [Tickish passes] -ref compiler/GHC/Types/Unique.hs: Note [Uniques-prelude - Uniques for wired-in Prelude things] -ref compiler/GHC/Types/Var.hs: Note [Promoted GADT data construtors] -ref compiler/GHC/Types/Var/Env.hs: Note [Rebinding] -ref compiler/GHC/Unit/Info.hs: Note [About units] -ref compiler/GHC/Unit/Module/Deps.hs: Note [Structure of dep_boot_mods] -ref compiler/GHC/Unit/State.hs: Note [About units] -ref compiler/GHC/Unit/State.hs: Note [About units] -ref compiler/GHC/Unit/State.hs: Note [About units] -ref compiler/GHC/Unit/State.hs: Note [Representation of module/name variable] -ref compiler/GHC/Unit/State.hs: Note [Representation of module/name variable] -ref compiler/GHC/Utils/Monad.hs: Note [multiShotIO] -ref compiler/GHC/Utils/Monad.hs: Note [inlineIdMagic] -ref compiler/GHC/Utils/Outputable.hs: Note [Print Hexadecimal Literals] -ref compiler/GHC/Utils/Ppr.hs: Note [Differences between libraries/pretty and compiler/GHC/Utils/Ppr.hs] -ref compiler/GHC/Utils/Ppr.hs: Note [Print Hexadecimal Literals] -ref compiler/GHC/Utils/Ppr.hs: Note [Print Hexadecimal Literals] -ref compiler/Language/Haskell/Syntax/Binds.hs: Note [fun_id in Match] -ref compiler/Language/Haskell/Syntax/Decls.hs: Note [TyVar binders for associated declarations] -ref compiler/Language/Haskell/Syntax/Decls.hs: Note [TyVar binders for associated declarations] -ref compiler/Language/Haskell/Syntax/Expr.hs: Note [Record Selectors in the AST] -ref compiler/Language/Haskell/Syntax/Expr.hs: Note [Record Selectors in the AST] -ref compiler/Language/Haskell/Syntax/Expr.hs: Note [ApplicativeDo] -ref compiler/Language/Haskell/Syntax/Expr.hs: Note [Applicative BodyStmt] -ref compiler/Language/Haskell/Syntax/Expr.hs: Note [Applicative BodyStmt] -ref compiler/Language/Haskell/Syntax/Expr.hs: Note [Quasi-quote overview] -ref compiler/Language/Haskell/Syntax/Extension.hs: Note [Constructor cannot happen] -ref compiler/Language/Haskell/Syntax/Pat.hs: Note [Disambiguating record fields] -ref compiler/Language/Haskell/Syntax/Type.hs: Note [HsArgPar] -ref compiler/Language/Haskell/Syntax/Type.hs: Note [HsArgPar] -ref compiler/ghc.mk: Note [Stage1Only vs stage=1] -ref configure.ac: Note [Linking ghc-bin against threaded stage0 RTS] -ref configure.ac: Note [tooldir: How GHC finds mingw on Windows] -ref configure.ac: Note [tooldir: How GHC finds mingw on Windows] -ref docs/core-spec/core-spec.mng: Note [TyBinders] -ref docs/core-spec/core-spec.mng: Note [Unused coercion variable in ForAllCo] -ref ghc.mk: Note [No stage2 packages when CrossCompiling or Stage1Only] -ref ghc.mk: Note [No stage2 packages when CrossCompiling or Stage1Only] -ref ghc.mk: Note [Stage1Only vs stage=1] -ref ghc.mk: Note [Stage1Only vs stage=1] -ref ghc.mk: Note [Dependencies between package-data.mk files] -ref ghc.mk: Note [No stage2 packages when CrossCompiling or Stage1Only] -ref ghc.mk: Note [Stage1Only vs stage=1] -ref ghc.mk: Note [No stage2 packages when CrossCompiling or Stage1Only] -ref ghc.mk: Note [No stage2 packages when CrossCompiling or Stage1Only] -ref ghc.mk: Note [CrossCompiling vs Stage1Only] -ref ghc.mk: Note [Stage1Only vs stage=1] -ref ghc/GHCi/UI.hs: Note [Changing language extensions for interactive evaluation] -ref ghc/GHCi/UI.hs: Note [ModBreaks.decls] -ref ghc/Main.hs: Note [Handling errors when parsing commandline flags] -ref ghc/ghc.mk: Note [Linking ghc-bin against threaded stage0 RTS] -ref ghc/ghc.mk: Note [Stage1Only vs stage=1] -ref ghc/ghc.mk: Note [Stage1Only vs stage=1] -ref hadrian/cfg/system.config.in: Note [tooldir: How GHC finds mingw on Windows] -ref hadrian/src/Expression.hs: Note [Linking ghc-bin against threaded stage0 RTS] -ref hadrian/src/Oracles/Setting.hs: Note [tooldir: How GHC finds mingw on Windows] -ref hadrian/src/Rules/Generate.hs: Note [tooldir: How GHC finds mingw on Windows] -ref hadrian/src/Rules/Libffi.hs: Note [Libffi indicating inputs] -ref libraries/base/Control/Concurrent/QSem.hs: Note [signal uninterruptible] -ref libraries/base/Control/Concurrent/QSem.hs: Note [signal uninterruptible] -ref libraries/base/Control/Concurrent/QSem.hs: Note [signal uninterruptible] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST: not producing lazy pairs] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST and multithreading] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST: not producing lazy pairs] -ref libraries/base/Control/Monad/ST/Lazy/Imp.hs: Note [Lazy ST: not producing lazy pairs] -ref libraries/base/Data/OldList.hs: Note [Left folds via right fold] -ref libraries/base/Data/OldList.hs: Note [INLINE unfoldr] -ref libraries/base/Data/OldList.hs: Note [INLINE unfoldr] -ref libraries/base/GHC/Enum.hs: Note [Enum Integer rules for literal 1] -ref libraries/base/GHC/Event/Windows.hsc: Note [Completion Ports] -ref libraries/base/GHC/Event/Windows.hsc: Note [Completion Ports] -ref libraries/base/GHC/Event/Windows.hsc: Note [Memory Management] -ref libraries/base/GHC/Event/Windows.hsc: Note [Memory Management] -ref libraries/base/GHC/Event/Windows/FFI.hsc: Note [Completion Ports] -ref libraries/base/GHC/ForeignPtr.hs: Note [Why FinalPtr] -ref libraries/base/GHC/ForeignPtr.hs: Note [Why FinalPtr] -ref libraries/base/GHC/ForeignPtr.hs: Note [MallocPtr finalizers] -ref libraries/base/GHC/ForeignPtr.hs: Note [MallocPtr finalizers] -ref libraries/base/GHC/ForeignPtr.hs: Note [MallocPtr finalizers] -ref libraries/base/GHC/IO/FD.hs: Note [nonblock] -ref libraries/base/GHC/IO/Handle/Internals.hs: Note [async] -ref libraries/base/GHC/IO/Handle/Internals.hs: Note [async] -ref libraries/base/GHC/IO/Handle/Text.hs: Note [#5536] -ref libraries/base/GHC/IO/Windows/Handle.hsc: Note [ReadFile/WriteFile] -ref libraries/base/GHC/IO/Windows/Handle.hsc: Note [ReadFile/WriteFile] -ref libraries/base/GHC/IO/Windows/Handle.hsc: Note [ReadFile/WriteFile] -ref libraries/base/GHC/IO/Windows/Handle.hsc: Note [ReadFile/WriteFile] -ref libraries/base/GHC/IO/Windows/Handle.hsc: Note [ReadFile/WriteFile] -ref libraries/base/GHC/List.hs: Note [Left folds via right fold] -ref libraries/base/GHC/List.hs: Note [Left folds via right fold] -ref libraries/base/GHC/List.hs: Note [Left fold via right fold] -ref libraries/base/GHC/List.hs: Note [Left folds via right fold] -ref libraries/base/GHC/List.hs: Note [Left folds via right fold] -ref libraries/base/GHC/List.hs: Note [Left folds via right fold] -ref libraries/base/GHC/List.hs: Note [scanrFB and evaluation] -ref libraries/base/GHC/List.hs: Note [scanrFB and evaluation] -ref libraries/base/GHC/List.hs: Note [Fusion for foldr2] -ref libraries/base/GHC/List.hs: Note [Fusion for foldr2] -ref libraries/base/GHC/Read.hs: Note [Why readField] -ref libraries/base/GHC/Read.hs: Note [Why readField] -ref libraries/base/GHC/Read.hs: Note [Why readField] -ref libraries/base/GHC/Read.hs: Note [Why readField] -ref libraries/base/GHC/Real.hs: Note [Numeric Stability of Enumerating Floating Numbers] -ref libraries/base/GHC/Real.hs: Note [Numeric Stability of Enumerating Floating Numbers] -ref libraries/base/GHC/Real.hs: Note [Numeric Stability of Enumerating Floating Numbers] -ref libraries/base/GHC/ST.hs: Note [Definition of runRW#] -ref libraries/base/GHC/TypeLits.hs: Note [NOINLINE someNatVal] -ref libraries/base/GHC/TypeNats.hs: Note [NOINLINE someNatVal] -ref libraries/base/GHC/TypeNats.hs: Note [NOINLINE someNatVal] -ref libraries/base/Unsafe/Coerce.hs: Note [Implementing unsafeCorece] -ref libraries/base/cbits/inputReady.c: Note [Guaranteed syscall time spent] -ref libraries/base/cbits/inputReady.c: Note [Guaranteed syscall time spent] -ref libraries/ghc-prim/GHC/Types.hs: Note [Linear Types] -ref libraries/ghci/GHCi/Message.hs: Note [Remote GHCi] -ref libraries/ghci/GHCi/Message.hs: Note [Remote Template Haskell] -ref libraries/ghci/GHCi/Message.hs: Note [Remote Template Haskell] -ref libraries/ghci/GHCi/RemoteTypes.hs: Note [External GHCi pointers] -ref libraries/ghci/GHCi/RemoteTypes.hs: Note [Remote GHCi] -ref libraries/ghci/GHCi/Run.hs: Note [Remote GHCi] -ref libraries/ghci/GHCi/TH.hs: Note [Remote Template Haskell] -ref libraries/ghci/GHCi/TH.hs: Note [Remote GHCi] -ref libraries/ghci/GHCi/TH.hs: Note [External GHCi pointers] -ref libraries/ghci/GHCi/TH.hs: Note [TH recover with -fexternal-interpreter] -ref libraries/ghci/GHCi/TH.hs: Note [TH recover with -fexternal-interpreter] -ref libraries/libiserv/src/IServ.hs: Note [Remote Template Haskell] -ref m4/fp_settings.m4: Note [tooldir: How GHC finds mingw on Windows] -ref mk/config.mk.in: Note [Stage number in build variables] -ref mk/config.mk.in: Note [Stage number in build variables] -ref mk/config.mk.in: Note [Stage number in build variables] -ref mk/config.mk.in: Note [Stage number in build variables] -ref mk/config.mk.in: Note [tooldir: How GHC finds mingw on Windows] -ref mk/config.mk.in: Note [CrossCompiling vs Stage1Only] -ref mk/config.mk.in: Note [CrossCompiling vs Stage1Only] -ref mk/config.mk.in: Note [Stage1Only vs stage=1] -ref mk/config.mk.in: Note [CrossCompiling vs Stage1Only] -ref mk/config.mk.in: Note [Stage1Only vs stage=1] -ref mk/config.mk.in: Note [Stage1Only vs stage=1] -ref mk/config.mk.in: Note [Stage1Only vs stage=1] -ref mk/config.mk.in: Note [No stage2 packages when CrossCompiling or Stage1Only] -ref mk/config.mk.in: Note [Disable -O2 in unregisterised mode] -ref mk/config.mk.in: Note [Disable -O2 in unregisterised mode] -ref mk/tree.mk: Note [Spaces in TEST_HC] -ref mk/warnings.mk: Note [Order of warning flags] -ref mk/warnings.mk: Note [Stage number in build variables] -ref mk/warnings.mk: Note [Order of warning flags] -ref rts/Apply.cmm: Note [Evaluating functions with profiling] -ref rts/Apply.cmm: Note [suspend duplicate work] -ref rts/Capability.c: Note [GC livelock] -ref rts/Capability.h: Note [allocation accounting] -ref rts/Compact.cmm: Note [compactAddWorker result] -ref rts/Compact.cmm: Note [compactAddWorker result] -ref rts/Interpreter.c: Note [Not true: ASSERT(Sp > SpLim)] -ref rts/Interpreter.c: Note [avoiding threadPaused] -ref rts/Interpreter.c: Note [upd-black-hole] -ref rts/Interpreter.c: Note [Evaluating functions with profiling] -ref rts/Interpreter.c: Note [Evaluating functions with profiling] -ref rts/Linker.c: Note [runtime-linker-support] -ref rts/Linker.c: Note [runtime-linker-phases] -ref rts/Linker.c: Note [weak-symbols-support] -ref rts/Linker.c: Note [RTLD_LOCAL] -ref rts/Linker.c: Note [RTLD_LOCAL] -ref rts/Linker.c: Note [runtime-linker-phases] -ref rts/Linker.c: Note [loadOc orderings] -ref rts/LinkerInternals.h: Note [No typedefs for customizable types] -ref rts/LinkerInternals.h: Note [No typedefs for customizable types] -ref rts/LinkerInternals.h: Note [TLSGD relocation] -ref rts/LinkerInternals.h: Note [No typedefs for customizable types] -ref rts/Messages.c: Note [BLACKHOLE pointing to IND] -ref rts/PrimOps.cmm: Note [Nonmoving write barrier in Perform{Put,Take}] -ref rts/PrimOps.cmm: Note [Nonmoving write barrier in Perform{Put,Take}] -ref rts/RaiseAsync.c: Note [Throw to self when masked] -ref rts/RtsFlags.c: Note [OPTION_SAFE vs OPTION_UNSAFE] -ref rts/RtsFlags.c: Note [OPTION_SAFE vs OPTION_UNSAFE] -ref rts/Schedule.c: Note [shutdown] -ref rts/Schedule.c: Note [GC livelock] -ref rts/Schedule.c: Note [GC livelock] -ref rts/Schedule.c: Note [avoiding threadPaused] -ref rts/Schedule.c: Note [Deadlock detection under nonmoving collector] -ref rts/Schedule.h: Note [shutdown] -ref rts/Sparks.c: Note [STATIC_LINK fields] -ref rts/StablePtr.c: Note [Enlarging the stable pointer table] -ref rts/StablePtr.c: Note [Enlarging the stable pointer table] -ref rts/Stats.c: Note [n_gc_threads] -ref rts/Stats.c: Note [RTS Stats Reporting] -ref rts/Stats.c: Note [RTS Stats Reporting] -ref rts/Stats.c: Note [Work Balance] -ref rts/Stats.c: Note [Internal Counter Stats] -ref rts/Stats.c: Note [RTS Stats Reporting] -ref rts/Stats.c: Note [RTS Stats Reporting] -ref rts/Stats.c: Note [Work Balance] -ref rts/Stats.c: Note [Work Balance] -ref rts/Stats.c: Note [Internal Counters Stats] -ref rts/StgCRun.c: Note [Windows Stack allocations] -ref rts/StgCRun.c: Note [Windows Stack allocations] -ref rts/StgCRun.c: Note [Windows Stack allocations] -ref rts/StgMiscClosures.cmm: Note [GHCi unboxed tuples stack spills] -ref rts/StgMiscClosures.cmm: Note [GHCi tuple layout] -ref rts/StgMiscClosures.cmm: Note [BLACKHOLE pointing to IND] -ref rts/StgMiscClosures.cmm: Note [suspend duplicate work] -ref rts/StgMiscClosures.cmm: Note [CHARLIKE and INTLIKE closures.] -ref rts/StgStartup.cmm: Note [avoiding threadPaused] -ref rts/StgStdThunks.cmm: Note [untag for prof] -ref rts/StgStdThunks.cmm: Note [untag for prof] -ref rts/StgStdThunks.cmm: Note [untag for prof] -ref rts/ThreadPaused.c: Note [upd-black-hole] -ref rts/ThreadPaused.c: Note [suspend duplicate work] -ref rts/Threads.c: Note [Throw to self when masked] -ref rts/Timer.c: Note [GC During Idle Time] -ref rts/Updates.cmm: Note [HpAlloc] -ref rts/Updates.cmm: Note [HpAlloc] -ref rts/Updates.cmm: Note [HpAlloc] -ref rts/include/Cmm.h: Note [Evaluating functions with profiling] -ref rts/include/Cmm.h: Note [Syntax of .cmm files] -ref rts/include/Stg.h: Note [Windows Stack allocations] -ref rts/include/ghc.mk: Note [tooldir: How GHC finds mingw on Windows] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [MADV_FREE and MADV_DONTNEED] -ref rts/include/rts/Flags.h: Note [Internal Counter Stats] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Flags.h: Note [Synchronization of flags and base APIs] -ref rts/include/rts/Linker.h: Note [runtime-linker-phases] -ref rts/include/rts/OSThreads.h: Note [SRW locks] -ref rts/include/rts/OSThreads.h: Note [SRW locks] -ref rts/include/rts/prof/CCS.h: Note [struct alignment] -ref rts/include/rts/prof/CCS.h: Note [struct alignment] -ref rts/include/rts/prof/CCS.h: Note [struct alignment] -ref rts/include/rts/prof/CCS.h: Note [struct alignment] -ref rts/include/rts/prof/CCS.h: Note [struct alignment] -ref rts/include/rts/storage/Block.h: Note [integer overflow] -ref rts/include/rts/storage/Block.h: Note [integer overflow] -ref rts/include/rts/storage/Block.h: Note [integer overflow] -ref rts/include/rts/storage/Closures.h: Note [CAF lists] -ref rts/include/rts/storage/Closures.h: Note [CAF lists] -ref rts/include/rts/storage/GC.h: Note [allocation accounting] -ref rts/include/stg/MachRegs.h: Note [Overlapping global registers] -ref rts/linker/Elf.c: Note [Many ELF Sections] -ref rts/linker/Elf.c: Note [Many ELF Sections] -ref rts/linker/Elf.c: Note [Many ELF Sections] -ref rts/linker/Elf.c: Note [PC bias] -ref rts/linker/Elf.c: Note [TLSGD relocation] -ref rts/linker/Elf.c: Note [Many ELF Sections] -ref rts/linker/Elf.c: Note [.LCTOC1 in PPC PIC code] -ref rts/linker/Elf.c: Note [Many ELF Sections] -ref rts/linker/LoadArchive.c: Note [MSVC import files (ext .lib)] -ref rts/linker/PEi386.c: Note [mingw-w64 name decoration scheme] -ref rts/linker/PEi386.c: Note [ELF constant in PE file] -ref rts/linker/PEi386.c: Note [mingw-w64 name decoration scheme] -ref rts/linker/PEi386.h: Note [mingw-w64 name decoration scheme] -ref rts/linker/PEi386.h: Note [mingw-w64 name decoration scheme] -ref rts/linker/PEi386.h: Note [mingw-w64 name decoration scheme] -ref rts/linker/SymbolExtras.c: Note [TLSGD relocation] -ref rts/linker/elf_reloc_aarch64.c: Note [PC bias aarch64] -ref rts/linker/elf_tlsgd.c: Note [TLSGD relocation] -ref rts/posix/OSMem.c: Note [MADV_FREE and MADV_DONTNEED] -ref rts/posix/OSMem.c: Note [MADV_FREE and MADV_DONTNEED] -ref rts/sm/Evac.c: Note [Deadlock detection under nonmoving collector] -ref rts/sm/Evac.c: Note [Deadlock detection under nonmoving collector] -ref rts/sm/Evac.c: Note [STATIC_LINK fields] -ref rts/sm/Evac.c: Note [BLACKHOLE pointing to IND] -ref rts/sm/Evac.c: Note [upd-black-hole] -ref rts/sm/GC.c: Note [STATIC_LINK fields] -ref rts/sm/GC.c: Note [Synchronising work stealing] -ref rts/sm/GC.c: Note [n_gc_threads] -ref rts/sm/GC.c: Note [Deadlock detection under nonmoving collector] -ref rts/sm/GC.c: Note [Synchronising work stealing] -ref rts/sm/GC.c: Note [n_gc_threads] -ref rts/sm/GC.c: Note [Work Balance] -ref rts/sm/GC.c: Note [Scaling retained memory] -ref rts/sm/GC.c: Note [Synchronising work stealing] -ref rts/sm/GC.c: Note [Synchronising work stealing] -ref rts/sm/GC.c: Note [Synchronising work stealing] -ref rts/sm/GC.c: Note [STATIC_LINK fields] -ref rts/sm/GC.c: Note [Synchronising work stealing] -ref rts/sm/GC.c: Note [Scaling retained memory] -ref rts/sm/GC.h: Note [Deadlock detection under nonmoving collector] -ref rts/sm/GCUtils.c: Note [big objects] -ref rts/sm/GCUtils.c: Note [big objects] -ref rts/sm/GCUtils.c: Note [big objects] -ref rts/sm/GCUtils.c: Note [big objects] -ref rts/sm/MarkWeak.c: Note [MallocPtr finalizers] -ref rts/sm/NonMovingMark.c: Note [Deadlock detection under nonmoving collector] -ref rts/sm/NonMovingMark.c: Note [Update rememembered set] -ref rts/sm/NonMovingMark.c: Note [upd-black-hole] -ref rts/sm/Scav.c: Note [Deadlock detection under nonmoving collector] -ref rts/sm/Scav.c: Note [upd-black-hole] -ref rts/sm/Scav.c: Note [avoiding threadPaused] -ref rts/sm/Storage.c: Note [STATIC_LINK fields] -ref rts/sm/Storage.c: Note [STATIC_LINK fields] -ref rts/sm/Storage.c: Note [dyn_caf_list] -ref rts/sm/Storage.c: Note [allocation accounting] -ref rts/sm/Storage.h: Note [STATIC_LINK fields] -ref rts/sm/Storage.h: Note [CAF lists] -ref rts/sm/Storage.h: Note [CAF lists] -ref rts/sm/Storage.h: Note [dyn_caf_list] -ref rts/win32/OSMem.c: Note [base memory] -ref rules/build-package-way.mk: Note [inconsistent distdirs] -ref rules/build-package.mk: Note [inconsistent distdirs] -ref rules/build-package.mk: Note [inconsistent distdirs] -ref rules/build-prog.mk: Note [inconsistent distdirs] -ref rules/build-prog.mk: Note [lib-depends] -ref rules/build-prog.mk: Note [inconsistent distdirs] -ref rules/distdir-way-opts.mk: Note [Stage number in build variables] -ref rules/haddock.mk: Note [inconsistent distdirs] -ref rules/hs-suffix-way-rules.mk: Note [Implicit rule search algorithm] -ref testsuite/config/ghc: Note [WayFlags] -ref testsuite/driver/runtests.py: Note [Mutating config.only] -ref testsuite/driver/runtests.py: Note [Running tests in /tmp] -ref testsuite/driver/testglobals.py: Note [validate and testsuite speed] -ref testsuite/driver/testglobals.py: Note [Haddock runtime stats files] -ref testsuite/driver/testglobals.py: Note [Running tests in /tmp] -ref testsuite/driver/testlib.py: Note [Why is there no stage1 setup function?] -ref testsuite/driver/testlib.py: Note [Why is there no stage1 setup function?] -ref testsuite/driver/testlib.py: Note [Mutating config.only] -ref testsuite/driver/testlib.py: Note [validate and testsuite speed] -ref testsuite/driver/testlib.py: Note [Universal newlines] -ref testsuite/driver/testlib.py: Note [Universal newlines] -ref testsuite/driver/testlib.py: Note [Universal newlines] -ref testsuite/driver/testlib.py: Note [Universal newlines] -ref testsuite/driver/testlib.py: Note [Output comparison] -ref testsuite/driver/testlib.py: Note [Null device handling] -ref testsuite/driver/testlib.py: Note [Output comparison] -ref testsuite/driver/testlib.py: Note [Null device handling] -ref testsuite/driver/testlib.py: Note [Output comparison] -ref testsuite/driver/testlib.py: Note [Output comparison] -ref testsuite/driver/testlib.py: Note [Null device handling] -ref testsuite/mk/boilerplate.mk: Note [Communicating options and variables to a submake] -ref testsuite/mk/boilerplate.mk: Note [Spaces in TEST_HC] -ref testsuite/mk/boilerplate.mk: Note [Spaces in TEST_HC] -ref testsuite/mk/boilerplate.mk: Note [Spaces in TEST_HC] -ref testsuite/mk/boilerplate.mk: Note [The TEST_HC variable] -ref testsuite/mk/boilerplate.mk: Note [WayFlags] -ref testsuite/mk/test.mk: Note [Running tests in /tmp] -ref testsuite/mk/test.mk: Note [validate and testsuite speed] -ref testsuite/mk/test.mk: Note [Communicating options and variables to a submake] -ref testsuite/mk/test.mk: Note [validate and testsuite speed] -ref testsuite/mk/test.mk: Note [Communicating options and variables to a submake] -ref testsuite/mk/test.mk: Note [The TEST_HC variable] -ref testsuite/tests/ghci/scripts/T19667Ghci.hs: Note [NOINLINE someNatVal] -ref testsuite/tests/indexed-types/should_compile/T18875.hs: Note [Type variable cycles in Givens] -ref testsuite/tests/indexed-types/should_fail/ExtraTcsUntch.hs: Note [Extra TcS Untouchables] -ref testsuite/tests/perf/haddock/all.T: Note [Haddock runtime stats files] -ref testsuite/tests/perf/join_points/join005.hs: Note [Don't CPR join points] -ref testsuite/tests/perf/should_run/all.T: Note [Solving from instances when interacting Dicts] -ref testsuite/tests/polykinds/CuskFam.hs: Note [Unifying implicit CUSK variables] -ref testsuite/tests/rts/linker/T11223/all.T: Note [weak-symbols-support] -ref testsuite/tests/simplCore/should_compile/T5776.hs: Note [Simplifying RULE lhs constraints] -ref testsuite/tests/simplCore/should_compile/simpl018.hs: Note [Float coercions (unlifted)] -ref testsuite/tests/stranal/sigs/T19871.hs: Note [Boxity Analysis] -ref testsuite/tests/typecheck/should_compile/CbvOverlap.hs: Note [Type variable cycles in Givens] -ref testsuite/tests/typecheck/should_compile/Improvement.hs: Note [No reduction for Derived class constraints] -ref testsuite/tests/typecheck/should_compile/LocalGivenEqs.hs: Note [When does an implication have given equalities?] -ref testsuite/tests/typecheck/should_compile/LocalGivenEqs.hs: Note [Type variable cycles in Givens] -ref testsuite/tests/typecheck/should_compile/LocalGivenEqs2.hs: Note [When does an implication have given equalities?] -ref testsuite/tests/typecheck/should_compile/T9117.hs: Note [Order of Coercible Instances] -ref testsuite/tests/typecheck/should_compile/tc200.hs: Note [Multiple instantiation] -ref testsuite/tests/typecheck/should_compile/tc228.hs: Note [Inference and implication constraints] -ref testsuite/tests/typecheck/should_compile/tc231.hs: Note [Important subtlety in oclose] -ref testsuite/tests/typecheck/should_fail/UnliftedNewtypesMultiFieldGadt.hs: Note [Kind-checking the field type] -ref testsuite/tests/typecheck/should_fail/tcfail093.hs: Note [Important subtlety in oclose] -ref testsuite/tests/typecheck/should_run/T16646.hs: Note [NOINLINE someNatVal] -ref testsuite/tests/typecheck/should_run/T19667.hs: Note [NOINLINE someNatVal] -ref utils/genapply/Main.hs: Note [jump_SAVE_CCCS] -ref utils/genapply/Main.hs: Note [jump_SAVE_CCCS] -ref utils/genapply/Main.hs: Note [jump_SAVE_CCCS] -ref utils/ghc-cabal/Main.hs: Note [Msys2 path translation bug] -ref utils/ghc-cabal/Main.hs: Note [Msys2 path translation bug] -ref utils/ghc-pkg/Main.hs: Note [Settings File] -ref utils/ghc-pkg/ghc.mk: Note [Why build certain utils twice?] -ref utils/ghc-pkg/ghc.mk: Note [Stage1Only vs stage=1] -ref utils/ghc-pkg/ghc.mk: Note [Why build certain utils twice?] -ref utils/ghc-pkg/ghc.mk: Note [Stage1Only vs stage=1] -ref utils/iserv/src/Main.hs: Note [Remote GHCi] -ref utils/llvm-targets/gen-data-layout.sh: Note [LLVM Configuration] -ref utils/notes-util/Notes.hs: Note [" <> T.unpack x <> "] -ref utils/notes-util/Notes.hs: Note [...] -ref utils/notes-util/test: Note [This is a Note reference broken across lines] -ref utils/notes-util/test: Note [Broken across a line in a C++ comment] -ref utils/notes-util/test: Note [Broken across a line in a C comment] -ref utils/notes-util/test: Note [Broken across a line in a Haskell comment] -ref utils/notes-util/test: Note [Broken across a line in a Python comment] -ref validate: Note [Default build system verbosity] -ref validate: Note [Default build system verbosity] -ref validate: Note [Default build system verbosity] -ref validate: Note [Running tests in /tmp] -ref validate: Note [Why is there no stage1 setup function?] - diff --git a/utils/notes-util/ghc.mk b/utils/notes-util/ghc.mk new file mode 100644 index 0000000000..99f8628b70 --- /dev/null +++ b/utils/notes-util/ghc.mk @@ -0,0 +1,18 @@ +# ----------------------------------------------------------------------------- +# +# (c) 2009 The University of Glasgow +# +# This file is part of the GHC build system. +# +# To understand how the build system works and how to modify it, see +# https://gitlab.haskell.org/ghc/ghc/wikis/building/architecture +# https://gitlab.haskell.org/ghc/ghc/wikis/building/modifying +# +# ----------------------------------------------------------------------------- + +utils/notes-util_USES_CABAL = YES +utils/notes-util_PACKAGE = notes-util +utils/notes-util_dist-install_PROGNAME = notes-util +utils/notes-util_dist-install_INSTALL = NO +utils/notes-util_dist-install_INSTALL_INPLACE = YES +$(eval $(call build-prog,utils/notes-util,dist-install,1)) diff --git a/utils/notes-util/notes-util.cabal b/utils/notes-util/notes-util.cabal index 643fd163fd..bba734e03b 100644 --- a/utils/notes-util/notes-util.cabal +++ b/utils/notes-util/notes-util.cabal @@ -8,7 +8,7 @@ author: Ben Gamari maintainer: ben@smart-cactus.org copyright: (c) 2022 Ben Gamari -executable ghc-notes +executable notes-util main-is: Main.hs other-modules: Notes build-depends: base >= 4 && < 5 , |