Update Trac ticket URLs to point to GitLab
authorRyan Scott <ryan.gl.scott@gmail.com>
Tue, 12 Mar 2019 22:15:38 +0000 (18:15 -0400)
committerMarge Bot <ben+marge-bot@smart-cactus.org>
Fri, 15 Mar 2019 14:17:54 +0000 (10:17 -0400)
This moves all URL references to Trac tickets to their corresponding
GitLab counterparts.

490 files changed:
HACKING.md
Makefile
README.md
aclocal.m4
compiler/basicTypes/Demand.hs
compiler/basicTypes/Id.hs
compiler/basicTypes/Lexeme.hs
compiler/basicTypes/MkId.hs
compiler/basicTypes/Module.hs
compiler/basicTypes/NameCache.hs
compiler/basicTypes/OccName.hs
compiler/basicTypes/PatSyn.hs
compiler/basicTypes/RdrName.hs
compiler/cmm/CmmSink.hs
compiler/cmm/CmmUtils.hs
compiler/cmm/PprC.hs
compiler/codeGen/StgCmmClosure.hs
compiler/codeGen/StgCmmExpr.hs
compiler/codeGen/StgCmmHeap.hs
compiler/coreSyn/CoreArity.hs
compiler/coreSyn/CoreFVs.hs
compiler/coreSyn/CoreLint.hs
compiler/coreSyn/CoreMap.hs
compiler/coreSyn/CoreOpt.hs
compiler/coreSyn/CorePrep.hs
compiler/coreSyn/CoreSubst.hs
compiler/coreSyn/CoreSyn.hs
compiler/coreSyn/CoreUnfold.hs
compiler/coreSyn/CoreUtils.hs
compiler/coreSyn/MkCore.hs
compiler/deSugar/Check.hs
compiler/deSugar/Desugar.hs
compiler/deSugar/DsBinds.hs
compiler/deSugar/DsExpr.hs
compiler/deSugar/DsMeta.hs
compiler/deSugar/DsMonad.hs
compiler/deSugar/DsUsage.hs
compiler/deSugar/DsUtils.hs
compiler/deSugar/Match.hs
compiler/deSugar/MatchCon.hs
compiler/deSugar/MatchLit.hs
compiler/ghci/ByteCodeGen.hs
compiler/ghci/Linker.hs
compiler/ghci/RtClosureInspect.hs
compiler/hsSyn/Convert.hs
compiler/hsSyn/HsBinds.hs
compiler/hsSyn/HsDecls.hs
compiler/hsSyn/HsExpr.hs
compiler/hsSyn/HsPat.hs
compiler/hsSyn/HsTypes.hs
compiler/hsSyn/HsUtils.hs
compiler/iface/BuildTyCl.hs
compiler/iface/FlagChecker.hs
compiler/iface/IfaceSyn.hs
compiler/iface/IfaceType.hs
compiler/iface/LoadIface.hs
compiler/iface/MkIface.hs
compiler/iface/TcIface.hs
compiler/iface/ToIface.hs
compiler/llvmGen/Llvm/Types.hs
compiler/llvmGen/LlvmCodeGen.hs
compiler/main/Ar.hs
compiler/main/CmdLineParser.hs
compiler/main/Constants.hs
compiler/main/DriverPipeline.hs
compiler/main/DynFlags.hs
compiler/main/ErrUtils.hs
compiler/main/GHC.hs
compiler/main/GhcMake.hs
compiler/main/HscTypes.hs
compiler/main/InteractiveEval.hs
compiler/main/Packages.hs
compiler/main/SysTools.hs
compiler/main/SysTools/Info.hs
compiler/main/SysTools/Process.hs
compiler/main/TidyPgm.hs
compiler/nativeGen/PPC/Ppr.hs
compiler/nativeGen/PprBase.hs
compiler/nativeGen/X86/Ppr.hs
compiler/parser/Lexer.x
compiler/parser/Parser.y
compiler/parser/RdrHsSyn.hs
compiler/prelude/PrelRules.hs
compiler/prelude/PrimOp.hs
compiler/prelude/TysPrim.hs
compiler/prelude/primops.txt.pp
compiler/rename/RnBinds.hs
compiler/rename/RnEnv.hs
compiler/rename/RnExpr.hs
compiler/rename/RnFixity.hs
compiler/rename/RnNames.hs
compiler/rename/RnPat.hs
compiler/rename/RnSource.hs
compiler/rename/RnSplice.hs
compiler/rename/RnTypes.hs
compiler/rename/RnUtils.hs
compiler/simplCore/CSE.hs
compiler/simplCore/CallArity.hs
compiler/simplCore/CoreMonad.hs
compiler/simplCore/Exitify.hs
compiler/simplCore/FloatIn.hs
compiler/simplCore/FloatOut.hs
compiler/simplCore/OccurAnal.hs
compiler/simplCore/SetLevels.hs
compiler/simplCore/SimplCore.hs
compiler/simplCore/SimplMonad.hs
compiler/simplCore/SimplUtils.hs
compiler/simplCore/Simplify.hs
compiler/simplStg/StgCse.hs
compiler/simplStg/StgLiftLams.hs
compiler/specialise/Rules.hs
compiler/specialise/SpecConstr.hs
compiler/specialise/Specialise.hs
compiler/stgSyn/CoreToStg.hs
compiler/stranal/DmdAnal.hs
compiler/stranal/WorkWrap.hs
compiler/stranal/WwLib.hs
compiler/typecheck/ClsInst.hs
compiler/typecheck/FunDeps.hs
compiler/typecheck/Inst.hs
compiler/typecheck/TcAnnotations.hs
compiler/typecheck/TcBinds.hs
compiler/typecheck/TcCanonical.hs
compiler/typecheck/TcDeriv.hs
compiler/typecheck/TcDerivInfer.hs
compiler/typecheck/TcDerivUtils.hs
compiler/typecheck/TcEnv.hs
compiler/typecheck/TcErrors.hs
compiler/typecheck/TcEvidence.hs
compiler/typecheck/TcExpr.hs
compiler/typecheck/TcFlatten.hs
compiler/typecheck/TcForeign.hs
compiler/typecheck/TcGenDeriv.hs
compiler/typecheck/TcGenFunctor.hs
compiler/typecheck/TcGenGenerics.hs
compiler/typecheck/TcHoleErrors.hs
compiler/typecheck/TcHsSyn.hs
compiler/typecheck/TcHsType.hs
compiler/typecheck/TcInstDcls.hs
compiler/typecheck/TcInteract.hs
compiler/typecheck/TcMType.hs
compiler/typecheck/TcMatches.hs
compiler/typecheck/TcPat.hs
compiler/typecheck/TcPatSyn.hs
compiler/typecheck/TcRnDriver.hs
compiler/typecheck/TcRnExports.hs
compiler/typecheck/TcRnMonad.hs
compiler/typecheck/TcRnTypes.hs
compiler/typecheck/TcRules.hs
compiler/typecheck/TcSMonad.hs
compiler/typecheck/TcSigs.hs
compiler/typecheck/TcSimplify.hs
compiler/typecheck/TcSplice.hs
compiler/typecheck/TcTyClsDecls.hs
compiler/typecheck/TcTyDecls.hs
compiler/typecheck/TcType.hs
compiler/typecheck/TcUnify.hs
compiler/typecheck/TcValidity.hs
compiler/types/Coercion.hs
compiler/types/FamInstEnv.hs
compiler/types/InstEnv.hs
compiler/types/Kind.hs
compiler/types/OptCoercion.hs
compiler/types/TyCoRep.hs
compiler/types/TyCon.hs
compiler/types/Type.hs
compiler/types/Unify.hs
compiler/utils/Binary.hs
compiler/utils/MonadUtils.hs
compiler/utils/Pretty.hs
configure.ac
distrib/remilestoning.pl
docs/users_guide/bugs.rst
docs/users_guide/editing-guide.rst
docs/users_guide/ghc_config.py.in
docs/users_guide/glasgow_exts.rst
docs/users_guide/using-optimisation.rst
ghc/GHCi/UI.hs
ghc/Main.hs
hadrian/README.md
hadrian/src/Rules/Gmp.hs
hadrian/src/Rules/Register.hs
hadrian/src/Rules/Test.hs
hadrian/src/Settings/Builders/RunTest.hs
hadrian/src/Settings/Flavours/Common.hs
includes/MachDeps.h
includes/Stg.h
libraries/base/Control/Arrow.hs
libraries/base/Control/Category.hs
libraries/base/Control/Monad.hs
libraries/base/Control/Monad/ST/Imp.hs
libraries/base/Control/Monad/Zip.hs
libraries/base/Data/Data.hs
libraries/base/Data/Foldable.hs
libraries/base/Data/OldList.hs
libraries/base/Data/Typeable/Internal.hs
libraries/base/Debug/Trace.hs
libraries/base/Foreign/Ptr.hs
libraries/base/GHC/Arr.hs
libraries/base/GHC/Event/Manager.hs
libraries/base/GHC/Float.hs
libraries/base/GHC/IO.hs
libraries/base/GHC/Int.hs
libraries/base/GHC/List.hs
libraries/base/GHC/Read.hs
libraries/base/GHC/Real.hs
libraries/base/System/Environment/ExecutablePath.hsc
libraries/base/System/Mem/Weak.hs
libraries/base/cbits/inputReady.c
libraries/base/tests/IO/hReady001.hs
libraries/base/tests/T11760.hs
libraries/base/tests/fromJust.hs
libraries/base/tests/genericNegative001.hs
libraries/ghc-prim/cbits/atomic.c
libraries/integer-gmp/changelog.md
libraries/integer-gmp/src/GHC/Integer/Logarithms/Internals.hs
libraries/template-haskell/Language/Haskell/TH/Ppr.hs
libraries/template-haskell/Language/Haskell/TH/Syntax.hs
mk/build.mk.sample
mk/flavours/validate.mk
mk/install.mk.in
packages
rts/Apply.cmm
rts/Linker.c
rts/ProfHeap.c
rts/RtsAPI.c
rts/RtsFlags.c
rts/RtsUtils.c
rts/Schedule.c
rts/StablePtr.c
rts/StgPrimFloat.c
rts/linker/LoadArchive.c
rts/posix/OSMem.c
rts/posix/Select.c
rts/sm/Storage.c
rts/win32/GetTime.c
rules/build-prog.mk
testsuite/driver/testlib.py
testsuite/mk/test.mk
testsuite/tests/annotations/should_fail/T10826.stderr
testsuite/tests/arrows/should_compile/arrowpat.hs
testsuite/tests/arrows/should_fail/T2111.hs
testsuite/tests/arrows/should_fail/all.T
testsuite/tests/arrows/should_fail/arrowfail004.hs
testsuite/tests/boxy/Compose.hs
testsuite/tests/codeGen/should_run/cgrun058.hs
testsuite/tests/codeGen/should_run/cgrun063.hs
testsuite/tests/codeGen/should_run/cgrun071.hs
testsuite/tests/deSugar/should_compile/T2409.hs
testsuite/tests/deSugar/should_compile/T3263-1.hs
testsuite/tests/deSugar/should_compile/T3263-2.hs
testsuite/tests/deSugar/should_compile/T5252.hs
testsuite/tests/deSugar/should_compile/ds062.hs
testsuite/tests/deSugar/should_compile/ds063.hs
testsuite/tests/deSugar/should_run/T12595.hs
testsuite/tests/deSugar/should_run/T246.hs
testsuite/tests/dependent/should_compile/T16326_Compile1.hs
testsuite/tests/deriving/should_compile/T2378.hs
testsuite/tests/deriving/should_compile/T2721.hs
testsuite/tests/deriving/should_compile/T2856.hs
testsuite/tests/deriving/should_compile/all.T
testsuite/tests/deriving/should_compile/deriving-1935.hs
testsuite/tests/deriving/should_compile/drv012.hs
testsuite/tests/deriving/should_fail/T2394.hs
testsuite/tests/deriving/should_fail/T2851.hs
testsuite/tests/deriving/should_fail/drvfail012.hs
testsuite/tests/deriving/should_run/T2529.hs
testsuite/tests/eyeball/T3116.hs
testsuite/tests/eyeball/record1.hs
testsuite/tests/ffi/should_fail/ccfail001.hs
testsuite/tests/ffi/should_fail/ccfail002.hs
testsuite/tests/gadt/CasePrune.hs
testsuite/tests/gadt/Session.hs
testsuite/tests/gadt/T1999a.hs
testsuite/tests/gadt/T2587.hs
testsuite/tests/gadt/T3013.hs
testsuite/tests/gadt/T3163.hs
testsuite/tests/gadt/data1.hs
testsuite/tests/gadt/data2.hs
testsuite/tests/gadt/gadt-fd.hs
testsuite/tests/gadt/gadt17.hs
testsuite/tests/gadt/gadt24.hs
testsuite/tests/gadt/karl1.hs
testsuite/tests/gadt/karl2.hs
testsuite/tests/gadt/records-fail1.hs
testsuite/tests/ghci/prog003/prog003.T
testsuite/tests/ghci/scripts/T11098.script
testsuite/tests/ghci/scripts/T2766.script
testsuite/tests/ghci/scripts/T3263.hs
testsuite/tests/ghci/scripts/ghci019.hs
testsuite/tests/ghci/scripts/ghci030.hs
testsuite/tests/ghci/scripts/ghci031.hs
testsuite/tests/ghci/scripts/ghci033.hs
testsuite/tests/ghci/scripts/ghci063.script
testsuite/tests/indexed-types/should_compile/IndTypesPerfMerge.hs
testsuite/tests/indexed-types/should_compile/PushedInAsGivens.hs
testsuite/tests/indexed-types/should_compile/Records.hs
testsuite/tests/indexed-types/should_compile/T2238.hs
testsuite/tests/indexed-types/should_compile/T2944.hs
testsuite/tests/indexed-types/should_compile/T3017.hs
testsuite/tests/indexed-types/should_compile/T3590.hs
testsuite/tests/indexed-types/should_compile/T4178.hs
testsuite/tests/indexed-types/should_compile/UnusedTyVarWarnings.hs
testsuite/tests/indexed-types/should_compile/UnusedTyVarWarningsNamedWCs.hs
testsuite/tests/indexed-types/should_fail/T2334A.hs
testsuite/tests/indexed-types/should_fail/T4272.hs
testsuite/tests/indexed-types/should_fail/T9357.hs
testsuite/tests/indexed-types/should_run/T2985.hs
testsuite/tests/lib/integer/integerGmpInternals.hs
testsuite/tests/llvm/should_compile/T5486.hs
testsuite/tests/llvm/should_compile/T5681.hs
testsuite/tests/llvm/should_run/subsections_via_symbols/all.T
testsuite/tests/module/T3776.hs
testsuite/tests/parser/should_compile/read066.hs
testsuite/tests/parser/should_compile/read_1821.hs
testsuite/tests/parser/should_fail/NoNumericUnderscores0.hs
testsuite/tests/parser/should_fail/NoNumericUnderscores1.hs
testsuite/tests/parser/should_fail/NumericUnderscoresFail0.hs
testsuite/tests/parser/should_fail/NumericUnderscoresFail1.hs
testsuite/tests/parser/should_fail/T3095.hs
testsuite/tests/parser/should_run/NumericUnderscores0.hs
testsuite/tests/parser/should_run/NumericUnderscores1.hs
testsuite/tests/parser/should_run/readRun004.hs
testsuite/tests/parser/unicode/brackets.hs
testsuite/tests/partial-sigs/should_compile/NamedWildcardsAsTyVars.hs
testsuite/tests/partial-sigs/should_compile/T12033.hs
testsuite/tests/partial-sigs/should_fail/NamedWildcardExplicitForall.hs
testsuite/tests/patsyn/should_fail/T14380.stderr
testsuite/tests/perf/compiler/T9872d.hs
testsuite/tests/perf/should_run/T14936.hs
testsuite/tests/perf/should_run/T149_A.hs
testsuite/tests/perf/should_run/T149_B.hs
testsuite/tests/perf/should_run/T5549.hs
testsuite/tests/pmcheck/should_compile/T12957a.hs
testsuite/tests/polykinds/T11248.hs
testsuite/tests/polykinds/T11480b.hs
testsuite/tests/polykinds/T7594.hs
testsuite/tests/polykinds/T8566a.hs
testsuite/tests/quotes/T2931.hs
testsuite/tests/quotes/T3572.hs
testsuite/tests/quotes/TH_scope.hs
testsuite/tests/rebindable/T303.hs
testsuite/tests/rebindable/all.T
testsuite/tests/rebindable/rebindable8.hs
testsuite/tests/rebindable/rebindable9.hs
testsuite/tests/rename/should_compile/T1789.hs
testsuite/tests/rename/should_compile/T1789_2.hs
testsuite/tests/rename/should_compile/T17a.hs
testsuite/tests/rename/should_compile/T17b.hs
testsuite/tests/rename/should_compile/T17c.hs
testsuite/tests/rename/should_compile/T17d.hs
testsuite/tests/rename/should_compile/T17e.hs
testsuite/tests/rename/should_compile/T1972.hs
testsuite/tests/rename/should_compile/T2205.hs
testsuite/tests/rename/should_compile/T2506.hs
testsuite/tests/rename/should_compile/T3221.hs
testsuite/tests/rename/should_compile/T3262.hs
testsuite/tests/rename/should_compile/rn051.hs
testsuite/tests/rename/should_compile/rn058.hs
testsuite/tests/rename/should_compile/rn062.hs
testsuite/tests/rename/should_fail/T12146.hs
testsuite/tests/rename/should_fail/T2490.hs
testsuite/tests/rename/should_fail/T2901.hs
testsuite/tests/rename/should_fail/T2993.hs
testsuite/tests/rename/should_fail/T3265.hs
testsuite/tests/rename/should_fail/T4042.hs
testsuite/tests/rename/should_fail/rnfail048.hs
testsuite/tests/rename/should_fail/rnfail052.hs
testsuite/tests/rename/should_fail/rnfail053.hs
testsuite/tests/rts/T10590.hs
testsuite/tests/simplCore/T9646/readme.txt
testsuite/tests/simplCore/should_compile/Makefile
testsuite/tests/simplCore/should_compile/T11562.hs
testsuite/tests/simplCore/should_compile/T2520.hs
testsuite/tests/simplCore/should_compile/T3016.hs
testsuite/tests/simplCore/should_compile/T3118.hs
testsuite/tests/simplCore/should_compile/T3234.hs
testsuite/tests/simplCore/should_compile/T4306.hs
testsuite/tests/simplCore/should_compile/T7702.hs
testsuite/tests/simplCore/should_compile/T7702plugin/T7702plugin.cabal
testsuite/tests/simplCore/should_compile/rule1.hs
testsuite/tests/simplCore/should_compile/simpl-T1370.hs
testsuite/tests/simplCore/should_compile/simpl014.hs
testsuite/tests/simplCore/should_compile/simpl017.hs
testsuite/tests/simplCore/should_compile/simpl018.hs
testsuite/tests/simplCore/should_compile/simpl019.hs
testsuite/tests/simplCore/should_compile/spec003.hs
testsuite/tests/simplCore/should_run/T13429_2.hs
testsuite/tests/simplCore/should_run/T2486.hs
testsuite/tests/simplCore/should_run/T3403.hs
testsuite/tests/simplCore/should_run/T3437.hs
testsuite/tests/simplCore/should_run/T5587.hs
testsuite/tests/simplCore/should_run/T9128.hs
testsuite/tests/stage1/T2632.hs
testsuite/tests/stranal/should_compile/T10482a.hs
testsuite/tests/stranal/should_compile/T1988.hs
testsuite/tests/stranal/should_compile/T9208.hs
testsuite/tests/stranal/should_compile/all.T
testsuite/tests/stranal/should_run/T11555a.hs
testsuite/tests/th/Makefile
testsuite/tests/th/T11629.hs
testsuite/tests/th/T2386.hs
testsuite/tests/th/T2597a.hs
testsuite/tests/th/T2597b.hs
testsuite/tests/th/T2674.hs
testsuite/tests/th/T3100.hs
testsuite/tests/th/T3467.hs
testsuite/tests/th/TH_1tuple.hs
testsuite/tests/th/TH_emptycase.hs
testsuite/tests/th/TH_reifyMkName.hs
testsuite/tests/th/TH_runIO.hs
testsuite/tests/th/TH_spliceGuard.hs
testsuite/tests/typecheck/should_compile/FD1.hs
testsuite/tests/typecheck/should_compile/FD2.hs
testsuite/tests/typecheck/should_compile/FD3.hs
testsuite/tests/typecheck/should_compile/FD4.hs
testsuite/tests/typecheck/should_compile/Makefile
testsuite/tests/typecheck/should_compile/T12734a.hs
testsuite/tests/typecheck/should_compile/T13651.hs
testsuite/tests/typecheck/should_compile/T1470.hs
testsuite/tests/typecheck/should_compile/T1495.hs
testsuite/tests/typecheck/should_compile/T2045.hs
testsuite/tests/typecheck/should_compile/T2433.hs
testsuite/tests/typecheck/should_compile/T2494-2.hs
testsuite/tests/typecheck/should_compile/T2494.hs
testsuite/tests/typecheck/should_compile/T2497.hs
testsuite/tests/typecheck/should_compile/T2572.hs
testsuite/tests/typecheck/should_compile/T2735.hs
testsuite/tests/typecheck/should_compile/T3018.hs
testsuite/tests/typecheck/should_compile/T3219.hs
testsuite/tests/typecheck/should_compile/T3346.hs
testsuite/tests/typecheck/should_compile/T3391.hs
testsuite/tests/typecheck/should_compile/T3955.hs
testsuite/tests/typecheck/should_compile/T9708.hs
testsuite/tests/typecheck/should_compile/T9971.hs
testsuite/tests/typecheck/should_compile/T9973.hs
testsuite/tests/typecheck/should_compile/all.T
testsuite/tests/typecheck/should_compile/syn-perf2.hs
testsuite/tests/typecheck/should_compile/tc208.hs
testsuite/tests/typecheck/should_compile/tc217.hs
testsuite/tests/typecheck/should_compile/tc220.hs
testsuite/tests/typecheck/should_compile/tc226.hs
testsuite/tests/typecheck/should_compile/tc227.hs
testsuite/tests/typecheck/should_compile/tc228.hs
testsuite/tests/typecheck/should_compile/tc230.hs
testsuite/tests/typecheck/should_compile/tc231.hs
testsuite/tests/typecheck/should_compile/tc232.hs
testsuite/tests/typecheck/should_compile/tc235.hs
testsuite/tests/typecheck/should_compile/tc239.hs
testsuite/tests/typecheck/should_compile/tc241.hs
testsuite/tests/typecheck/should_compile/tc242.hs
testsuite/tests/typecheck/should_fail/FDsFromGivens.hs
testsuite/tests/typecheck/should_fail/T10715.hs
testsuite/tests/typecheck/should_fail/T11948.hs
testsuite/tests/typecheck/should_fail/T1633.hs
testsuite/tests/typecheck/should_fail/T1899.hs
testsuite/tests/typecheck/should_fail/T2126.hs
testsuite/tests/typecheck/should_fail/T2307.hs
testsuite/tests/typecheck/should_fail/T2414.hs
testsuite/tests/typecheck/should_fail/T2538.hs
testsuite/tests/typecheck/should_fail/T2714.hs
testsuite/tests/typecheck/should_fail/T2806.hs
testsuite/tests/typecheck/should_fail/T2994.hs
testsuite/tests/typecheck/should_fail/T3155.hs
testsuite/tests/typecheck/should_fail/T3176.hs
testsuite/tests/typecheck/should_fail/T3323.hs
testsuite/tests/typecheck/should_fail/T3406.hs
testsuite/tests/typecheck/should_fail/T3613.hs
testsuite/tests/typecheck/should_fail/T5236.hs
testsuite/tests/typecheck/should_fail/T8392a.hs
testsuite/tests/typecheck/should_fail/T8806.hs
testsuite/tests/typecheck/should_fail/T8883.hs
testsuite/tests/typecheck/should_fail/T9858a.hs
testsuite/tests/typecheck/should_fail/TcCoercibleFail.hs
testsuite/tests/typecheck/should_fail/all.T
testsuite/tests/typecheck/should_fail/tcfail138.hs
testsuite/tests/typecheck/should_fail/tcfail169.hs
testsuite/tests/typecheck/should_fail/tcfail175.hs
testsuite/tests/typecheck/should_fail/tcfail177.hs
testsuite/tests/typecheck/should_fail/tcfail178.hs
testsuite/tests/typecheck/should_fail/tcfail185.hs
testsuite/tests/typecheck/should_fail/tcfail186.hs
testsuite/tests/typecheck/should_fail/tcfail187.hs
testsuite/tests/typecheck/should_fail/tcfail188.hs
testsuite/tests/typecheck/should_fail/tcfail204.hs
testsuite/tests/typecheck/should_run/Defer01.hs
utils/gen-dll/Main.hs
utils/ghc-in-ghci/settings.ghci
utils/ghc-pkg/Main.hs
utils/runghc/Main.hs

index cb68889..0a532b4 100644 (file)
@@ -8,9 +8,9 @@ information to help you get started right away.
 The GHC Developer's Wiki
 ========================
 
-The home for GHC hackers is our Trac instance, located here:
+The home for GHC hackers is our GitLab instance, located here:
 
-<http://ghc.haskell.org/trac/ghc>
+<https://gitlab.haskell.org/ghc/ghc>
 
 From here, you can file bugs (or look them up,) use the wiki, view the
 `git` history, among other things. Of particular note is the building
@@ -64,8 +64,8 @@ Now, hack on your copy and rebuild (with `make`) as necessary.
 Then start by making your commits however you want. When you're done, you can submit
  a pull request on Github for small changes. For larger changes the patch needs to be
  submitted to [Phabricator](https://phabricator.haskell.org/) for code review.
- The GHC Trac Wiki has a good summary for the [overall process](https://ghc.haskell.org/trac/ghc/wiki/WorkingConventions/FixingBugs)
- as well as a guide on 
+ The GHC Wiki has a good summary for the [overall process](https://ghc.haskell.org/trac/ghc/wiki/WorkingConventions/FixingBugs)
+ as well as a guide on
  [how to use Phabricator/arcanist](https://ghc.haskell.org/trac/ghc/wiki/Phabricator).
 
 
index 73dc7ed..f172ab0 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -22,7 +22,7 @@ MAKEFLAGS += --no-builtin-rules
 # -----------------------------------------------------------------------------
 # Sanitize environment
 
-# See Trac #11530
+# See #11530
 export GREP_OPTIONS :=
 
 ifneq "$(filter maintainer-clean distclean clean clean_% help,$(MAKECMDGOALS))" ""
index 02bf4a8..ef6652a 100644 (file)
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ environment for the Haskell functional programming language.
 
 For more information, visit [GHC's web site][1].
 
-Information for developers of GHC can be found on the [GHC Trac][2].
+Information for developers of GHC can be found on the [GHC issue tracker][2].
 
 
 Getting the Source
index 1647119..1d19b30 100644 (file)
@@ -1483,7 +1483,7 @@ AC_SUBST([GhcPkgCmd])
 # to compile .hc code.
 #
 # -fwrapv is needed for gcc to emit well-behaved code in the presence of
-# integer wrap around. (Trac #952)
+# integer wrap around. (#952)
 #
 AC_DEFUN([FP_GCC_EXTRA_FLAGS],
 [AC_REQUIRE([FP_GCC_VERSION])
index 52bdf67..184f3d5 100644 (file)
@@ -124,7 +124,7 @@ mkJointDmds ss as = zipWithEqual "mkJointDmds" mkJointDmd ss as
 Note [Exceptions and strictness]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 We used to smart about catching exceptions, but we aren't anymore.
-See Trac #14998 for the way it's resolved at the moment.
+See #14998 for the way it's resolved at the moment.
 
 Here's a historic breakdown:
 
@@ -138,17 +138,17 @@ their argument, which is useful information for usage analysis. Still with a
 
 In 7c0fff4 (July 15), Simon argued that giving `catch#` et al. a
 'strictApply1Dmd' leads to substantial performance gains. That was at the cost
-of correctness, as Trac #10712 proved. So, back to 'lazyApply1Dmd' in
+of correctness, as #10712 proved. So, back to 'lazyApply1Dmd' in
 28638dfe79e (Dec 15).
 
-Motivated to reproduce the gains of 7c0fff4 without the breakage of Trac #10712,
-Ben opened Trac #11222. Simon made the demand analyser "understand catch" in
+Motivated to reproduce the gains of 7c0fff4 without the breakage of #10712,
+Ben opened #11222. Simon made the demand analyser "understand catch" in
 9915b656 (Jan 16) by adding a new 'catchArgDmd', which basically said to call
 its argument strictly, but also swallow any thrown exceptions in
 'postProcessDmdResult'. This was realized by extending the 'Str' constructor of
 'ArgStr' with a 'ExnStr' field, indicating that it catches the exception, and
 adding a 'ThrowsExn' constructor to the 'Termination' lattice as an element
-between 'Dunno' and 'Diverges'. Then along came Trac #11555 and finally #13330,
+between 'Dunno' and 'Diverges'. Then along came #11555 and finally #13330,
 so we had to revert to 'lazyApply1Dmd' again in 701256df88c (Mar 17).
 
 This left the other variants like 'catchRetry#' having 'catchArgDmd', which is
@@ -159,10 +159,10 @@ there was none. We removed the last usages of 'catchArgDmd' in 00b8ecb7
 removed in ef6b283 (Jan 19): We got rid of 'ThrowsExn' and 'ExnStr' again and
 removed any code that was dealing with the peculiarities.
 
-Where did the speed-ups vanish to? In Trac #14998, item 3 established that
+Where did the speed-ups vanish to? In #14998, item 3 established that
 turning 'catch#' strict in its first argument didn't bring back any of the
 alleged performance benefits. Item 2 of that ticket finally found out that it
-was entirely due to 'catchException's new (since Trac #11555) definition, which
+was entirely due to 'catchException's new (since #11555) definition, which
 was simply
 
     catchException !io handler = catch io handler
@@ -312,7 +312,7 @@ splitStrProdDmd n (SProd ds) = WARN( not (ds `lengthIs` n),
                                Just ds
 splitStrProdDmd _ (SCall {}) = Nothing
       -- This can happen when the programmer uses unsafeCoerce,
-      -- and we don't then want to crash the compiler (Trac #9208)
+      -- and we don't then want to crash the compiler (#9208)
 
 {-
 ************************************************************************
@@ -482,7 +482,7 @@ addCaseBndrDmd (JD { sd = ms, ud = mu }) alt_dmds
 The demand on a binder in a case alternative comes
   (a) From the demand on the binder itself
   (b) From the demand on the case binder
-Forgetting (b) led directly to Trac #10148.
+Forgetting (b) led directly to #10148.
 
 Example. Source code:
   f x@(p,_) = if p then foo x else True
@@ -500,7 +500,7 @@ After strictness analysis:
         True -> foo wild_X7 }
 
 It's true that ds_dnz is *itself* absent, but the use of wild_X7 means
-that it is very much alive and demanded.  See Trac #10148 for how the
+that it is very much alive and demanded.  See #10148 for how the
 consequences play out.
 
 This is needed even for non-product types, in case the case-binder
@@ -603,7 +603,7 @@ splitUseProdDmd n (UProd ds)  = WARN( not (ds `lengthIs` n),
                                 Just ds
 splitUseProdDmd _ (UCall _ _) = Nothing
       -- This can happen when the programmer uses unsafeCoerce,
-      -- and we don't then want to crash the compiler (Trac #9208)
+      -- and we don't then want to crash the compiler (#9208)
 
 useCount :: Use u -> Count
 useCount Abs         = One
@@ -627,7 +627,7 @@ isStrictDmd returns true only of demands that are
    both strict
    and  used
 In particular, it is False for <HyperStr, Abs>, which can and does
-arise in, say (Trac #7319)
+arise in, say (#7319)
    f x = raise# <some exception>
 Then 'x' is not used, so f gets strictness <HyperStr,Abs> -> .
 Now the w/w generates
@@ -637,7 +637,7 @@ At this point we really don't want to convert to
    fx = case absentError "unused" of x -> raise <some exception>
 Since the program is going to diverge, this swaps one error for another,
 but it's really a bad idea to *ever* evaluate an absent argument.
-In Trac #7319 we get
+In #7319 we get
    T7319.exe: Oops!  Entered absent arg w_s1Hd{v} [lid] [base:GHC.Base.String{tc 36u}]
 
 Note [Dealing with call demands]
@@ -844,7 +844,7 @@ Consider this:
 where A,B are the constructors of a GADT.  We'll get a U(U,U) demand
 on x from the A branch, but that's a stupid demand for x itself, which
 has type 'a'. Indeed we get ASSERTs going off (notably in
-splitUseProdDmd, Trac #8569).
+splitUseProdDmd, #8569).
 
 Bottom line: we really don't want to have a binder whose demand is more
 deeply-nested than its type.  There are various ways to tackle this.
@@ -1501,7 +1501,7 @@ There are several wrinkles:
 
 * In a previous incarnation of GHC we needed to be extra careful in the
   case of an *unlifted type*, because unlifted values are evaluated
-  even if they are not used.  Example (see Trac #9254):
+  even if they are not used.  Example (see #9254):
      f :: (() -> (# Int#, () #)) -> ()
           -- Strictness signature is
           --    <C(S(LS)), 1*C1(U(A,1*U()))>
@@ -1696,7 +1696,7 @@ That's fine: if we are doing strictness analysis we are also doing inlining,
 so we'll have inlined 'op' into a cast.  So we can bale out in a conservative
 way, returning nopDmdType.
 
-It is (just.. Trac #8329) possible to be running strictness analysis *without*
+It is (just.. #8329) possible to be running strictness analysis *without*
 having inlined class ops from single-method classes.  Suppose you are using
 ghc --make; and the first module has a local -O0 flag.  So you may load a class
 without interface pragmas, ie (currently) without an unfolding for the class
index 199842c..04840c1 100644 (file)
@@ -386,7 +386,7 @@ of reasons:
  * Look them up in the current substitution when we come across
    occurrences of them (in Subst.lookupIdSubst). Lacking this we
    can get an out-of-date unfolding, which can in turn make the
-   simplifier go into an infinite loop (Trac #9857)
+   simplifier go into an infinite loop (#9857)
 
  * Ensure that for dfuns that the specialiser does not float dict uses
    above their defns, which would prevent good simplifications happening.
@@ -560,7 +560,7 @@ un-saturated.  Example:
 
 This has a compulsory unfolding because we can't lambda-bind those
 arguments.  But the compulsory unfolding may leave levity-polymorphic
-lambdas if it is not applied to enough arguments; e.g. (Trac #14561)
+lambdas if it is not applied to enough arguments; e.g. (#14561)
   bad :: forall (a :: TYPE r). a -> a
   bad = unsafeCoerce#
 
@@ -569,7 +569,7 @@ And we want that magic to apply to levity-polymorphic compulsory-inline things.
 The easiest way to do this is for hasNoBinding to return True of all things
 that have compulsory unfolding.  A very Ids with a compulsory unfolding also
 have a binding, but it does not harm to say they don't here, and its a very
-simple way to fix Trac #14561.
+simple way to fix #14561.
 
 Note [Primop wrappers]
 ~~~~~~~~~~~~~~~~~~~~~~
@@ -942,7 +942,7 @@ where the '*' means 'LoopBreaker'.  Then if we float we must get
 
 where g' is also marked as LoopBreaker.  If not, terrible things
 can happen if we re-simplify the binding (and the Simplifier does
-sometimes simplify a term twice); see Trac #4345.
+sometimes simplify a term twice); see #4345.
 
 It's not so simple to retain
   * worker info
index d397dea..00559ab 100644 (file)
@@ -159,9 +159,9 @@ okConIdOcc str = okIdOcc str ||
                  is_tuple_name1 True  str ||
                    -- Is it a boxed tuple...
                  is_tuple_name1 False str ||
-                   -- ...or an unboxed tuple (Trac #12407)...
+                   -- ...or an unboxed tuple (#12407)...
                  is_sum_name1 str
-                   -- ...or an unboxed sum (Trac #12514)?
+                   -- ...or an unboxed sum (#12514)?
   where
     -- check for tuple name, starting at the beginning
     is_tuple_name1 True  ('(' : rest)       = is_tuple_name2 True  rest
index e3b928c..85e4905 100644 (file)
@@ -746,7 +746,7 @@ constructor has no wrapper, but whether a constructor has a wrapper depends, for
 instance, on the order of type argument of that constructors. Therefore changing
 the order of type argument could make previously working RULEs fail.
 
-See also https://ghc.haskell.org/trac/ghc/ticket/15840 .
+See also https://gitlab.haskell.org/ghc/ghc/issues/15840 .
 
 
 Note [Bangs on imported data constructors]
@@ -778,7 +778,7 @@ We certainly do not want to make a wrapper
 For a start, it's still to generate a no-op.  But worse, since wrappers
 are currently injected at TidyCore, we don't even optimise it away!
 So the stupid case expression stays there.  This actually happened for
-the Integer data type (see Trac #1600 comment:66)!
+the Integer data type (see #1600 comment:66)!
 
 Note [Data con wrappers and GADT syntax]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -821,7 +821,7 @@ strictness/unpackedness to use for the fields of a data type constructor. But
 there is an exception to this rule: newtype constructors. You might not think
 that newtypes would pose a challenge, since newtypes are seemingly forbidden
 from having strictness annotations in the first place. But consider this
-(from Trac #16141):
+(from #16141):
 
   {-# LANGUAGE StrictData #-}
   {-# OPTIONS_GHC -O #-}
@@ -1045,7 +1045,7 @@ And it'd be fine to unpack a product type with existential components
 too, but that would require a bit more plumbing, so currently we don't.
 
 So for now we require: null (dataConExTyCoVars data_con)
-See Trac #14978
+See #14978
 
 Note [Unpack one-wide fields]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1175,7 +1175,7 @@ mkPrimOpId prim_op
                -- We give PrimOps a NOINLINE pragma so that we don't
                -- get silly warnings from Desugar.dsRule (the inline_shadows_rule
                -- test) about a RULE conflicting with a possible inlining
-               -- cf Trac #7287
+               -- cf #7287
 
 -- For each ccall we manufacture a separate CCallOpId, giving it
 -- a fresh unique, a type that is correct for this particular ccall,
@@ -1209,7 +1209,7 @@ mkFCallId dflags uniq fcall ty
     strict_sig = mkClosedStrictSig (replicate arity topDmd) topRes
     -- the call does not claim to be strict in its arguments, since they
     -- may be lifted (foreign import prim) and the called code doesn't
-    -- necessarily force them. See Trac #11076.
+    -- necessarily force them. See #11076.
 {-
 ************************************************************************
 *                                                                      *
@@ -1499,7 +1499,7 @@ are truly used call-by-need, with no code motion.  Key examples:
   Again, it's clear that 'a' will be evaluated strictly (and indeed
   applied to a state token) but we want to make sure that any exceptions
   arising from the evaluation of 'a' are caught by the catch (see
-  Trac #11555).
+  #11555).
 
 Implementing 'lazy' is a bit tricky:
 
@@ -1513,7 +1513,7 @@ Implementing 'lazy' is a bit tricky:
   are exposed in the interface file.  Otherwise, the unfolding for
   (say) pseq in the interface file will not mention 'lazy', so if we
   inline 'pseq' we'll totally miss the very thing that 'lazy' was
-  there for in the first place. See Trac #3259 for a real world
+  there for in the first place. See #3259 for a real world
   example.
 
 * Suppose CorePrep sees (catch# (lazy e) b).  At all costs we must
@@ -1550,7 +1550,7 @@ if library authors could explicitly tell the compiler that a certain lambda is
 called at most once. The oneShot function allows that.
 
 'oneShot' is levity-polymorphic, i.e. the type variables can refer to unlifted
-types as well (Trac #10744); e.g.
+types as well (#10744); e.g.
    oneShot (\x:Int# -> x +# 1#)
 
 Like most magic functions it has a compulsory unfolding, so there is no need
index ec3a946..9c9547f 100644 (file)
@@ -199,7 +199,7 @@ import {-# SOURCE #-} Packages (componentIdString, improveUnitId, PackageConfigM
 --        only ever ComponentIds, and some ComponentIds happen to have
 --        more information (UnitIds).
 --      - Same as Language.Haskell.TH.Syntax:PkgName, see
---          https://ghc.haskell.org/trac/ghc/ticket/10279
+--          https://gitlab.haskell.org/ghc/ghc/issues/10279
 --      - The same as PackageKey in GHC 7.10 (we renamed it because
 --        they don't necessarily identify packages anymore.)
 --      - Same as -this-package-key/-package-name flags
@@ -217,7 +217,7 @@ import {-# SOURCE #-} Packages (componentIdString, improveUnitId, PackageConfigM
 -- PackageName: The "name" field in a Cabal file, something like "lens".
 --      - Same as Distribution.Package.PackageName
 --      - DIFFERENT FROM Language.Haskell.TH.Syntax:PkgName, see
---          https://ghc.haskell.org/trac/ghc/ticket/10279
+--          https://gitlab.haskell.org/ghc/ghc/issues/10279
 --      - DIFFERENT FROM -package-name flag
 --      - DIFFERENT FROM the 'name' field in an installed package
 --        information.  This field could more accurately be described
index 13fb1f5..f845bc9 100644 (file)
@@ -68,7 +68,7 @@ are two reasons why we might look up an Orig RdrName for built-in syntax,
   * Template Haskell turns a BuiltInSyntax Name into a TH.NameG
     (DsMeta.globalVar), and parses a NameG into an Orig RdrName
     (Convert.thRdrName).  So, e.g. $(do { reify '(,); ... }) will
-    go this route (Trac #8954).
+    go this route (#8954).
 
 -}
 
index cb846f7..bbd40f8 100644 (file)
@@ -790,7 +790,7 @@ type TidyOccEnv = UniqFM Int
      - We use trailing digits to subtly indicate a unification variable
        in typechecker error message; see TypeRep.tidyTyVarBndr
 
-We have to take care though! Consider a machine-generated module (Trac #10370)
+We have to take care though! Consider a machine-generated module (#10370)
   module Foo where
      a1 = e1
      a2 = e2
index 2f8cee4..fe296bf 100644 (file)
@@ -118,7 +118,7 @@ In a pattern synonym signature we write
 Note that the "required" context comes first, then the "provided"
 context.  Moreover, the "required" context must not mention
 existentially-bound type variables; that is, ones not mentioned in
-res_ty.  See lots of discussion in Trac #10928.
+res_ty.  See lots of discussion in #10928.
 
 If there is no "provided" context, you can omit it; but you
 can't omit the "required" part (unless you omit both).
index 60e4e84..3dfe916 100644 (file)
@@ -509,7 +509,7 @@ gre_lcl is True, or gre_imp is non-empty.
 
 It is just possible to have *both* if there is a module loop: a Name
 is defined locally in A, and also brought into scope by importing a
-module that SOURCE-imported A.  Exapmle (Trac #7672):
+module that SOURCE-imported A.  Exapmle (#7672):
 
  A.hs-boot   module A where
                data T
@@ -1256,7 +1256,7 @@ Rationale for (a).  Consider
 The unqualified 'x' can only come from import #2.  The qualified 'M.x'
 could come from either, but bestImport picks import #2, because it is
 more likely to be useful in other imports, as indeed it is in this
-case (see Trac #5211 for a concrete example).
+case (see #5211 for a concrete example).
 
 But the rules are not perfect; consider
    import qualified M  -- Import #1
index 6317cfe..26d0a6f 100644 (file)
@@ -133,7 +133,7 @@ elemLRegSet l = IntSet.member (getKey (getUnique l))
 --
 -- a nice loop, but we didn't eliminate the silly assignment at the end.
 -- See Note [dependent assignments], which would probably fix this.
--- This is #8336 on Trac.
+-- This is #8336.
 --
 -- -----------
 -- (2) From stg_atomically_frame in PrimOps.cmm
index 5cfc5f4..8a3b857 100644 (file)
@@ -448,7 +448,7 @@ regsOverlap _ reg reg' = reg == reg'
 --
 -- We must check for overlapping registers and not just equal
 -- registers here, otherwise CmmSink may incorrectly reorder
--- assignments that conflict due to overlap. See Trac #10521 and Note
+-- assignments that conflict due to overlap. See #10521 and Note
 -- [Overlapping global registers].
 regUsedIn :: DynFlags -> CmmReg -> CmmExpr -> Bool
 regUsedIn dflags = regUsedIn_ where
index 4763c5d..bd019b1 100644 (file)
@@ -179,7 +179,7 @@ pprAlignment words =
 --
 -- It's a reasonable assumption also known as natural alignment.
 -- Although some architectures have different alignment rules.
--- One of known exceptions is m68k (Trac #11395, comment:16) where:
+-- One of known exceptions is m68k (#11395, comment:16) where:
 --   __alignof__(StgWord) == 2, sizeof(StgWord) == 4
 --
 -- Thus we explicitly increase alignment by using
index 8a32a7f..fff2078 100644 (file)
@@ -732,7 +732,7 @@ blackHoleOnEntry cl_info
 {- Note [Black-holing non-updatable thunks]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 We must not black-hole non-updatable (single-entry) thunks otherwise
-we run into issues like Trac #10414. Specifically:
+we run into issues like #10414. Specifically:
 
   * There is no reason to black-hole a non-updatable thunk: it should
     not be competed for by multiple threads
@@ -745,7 +745,7 @@ we run into issues like Trac #10414. Specifically:
      - is not updated (of course)
      - hence, if it is black-holed and another thread tries to evaluate
        it, that thread will block forever
-    This actually happened in Trac #10414.  So we do not black-hole
+    This actually happened in #10414.  So we do not black-hole
     non-updatable thunks.
 
   * How could two threads evaluate the same non-updatable (single-entry)
@@ -755,7 +755,7 @@ we run into issues like Trac #10414. Specifically:
     thunk, because lazy black-holing only affects thunks with an
     update frame on the stack.
 
-Here is and example due to Reid Barton (Trac #10414):
+Here is and example due to Reid Barton (#10414):
     x = \u []  concat [[1], []]
 with the following definitions,
 
index 5ad2e98..70a044a 100644 (file)
@@ -375,7 +375,7 @@ Suppose we have this STG code:
    f = \[s : State# RealWorld] ->
        case s of _ -> blah
 This is very odd.  Why are we scrutinising a state token?  But it
-can arise with bizarre NOINLINE pragmas (Trac #9964)
+can arise with bizarre NOINLINE pragmas (#9964)
     crash :: IO ()
     crash = IO (\s -> let {-# NOINLINE s' #-}
                           s' = s
@@ -532,7 +532,7 @@ See Note [case on bool]
 
 It's odd, and it's flagrantly inconsistent with the rules described
 Note [Compiling case expressions].  However, after eliminating the
-tagToEnum# (Trac #13397) we will have:
+tagToEnum# (#13397) we will have:
    case (a>b) of ...
 Rather than make it behave quite differently, I am testing for a
 comparison operator here in in the general case as well.
index 3b170eb..da9e85f 100644 (file)
@@ -519,7 +519,7 @@ heapCheck checkStack checkYield do_gc code
                     [" Trying to allocate more than "++show mBLOCK_SIZE++" bytes.",
                      "",
                      "This is currently not possible due to a limitation of GHC's code generator.",
-                     "See http://ghc.haskell.org/trac/ghc/ticket/4505 for details.",
+                     "See https://gitlab.haskell.org/ghc/ghc/issues/4505 for details.",
                      "Suggestion: read data from a file instead of having large static data",
                      "structures in code."]
                  | hpHw > 0  = Just (mkIntExpr dflags (hpHw * (wORD_SIZE dflags)))
index afd6759..5f7f559 100644 (file)
@@ -220,7 +220,7 @@ Now suppose we have:
 Now we want the built-in op/$dfList rule will fire to give
    blah = $copList dCInt
 
-But with eta-expansion 'blah' might (and in Trac #3772, which is
+But with eta-expansion 'blah' might (and in #3772, which is
 slightly more complicated, does) turn into
 
    blah = op (\eta. ($dfList dCInt |> sym co) eta)
@@ -302,7 +302,7 @@ This isn't really right in the presence of seq.  Consider
 This should diverge!  But if we eta-expand, it won't.  We ignore this
 "problem" (unless -fpedantic-bottoms is on), because being scrupulous
 would lose an important transformation for many programs. (See
-Trac #5587 for an example.)
+#5587 for an example.)
 
 Consider also
         f = \x -> error "foo"
@@ -322,7 +322,7 @@ this transformation.  So we try to limit it as much as possible:
 
  (1) Do NOT move a lambda outside a known-bottom case expression
        case undefined of { (a,b) -> \y -> e }
-     This showed up in Trac #5557
+     This showed up in #5557
 
  (2) Do NOT move a lambda outside a case if all the branches of
      the case are known to return bottom.
@@ -334,7 +334,7 @@ this transformation.  So we try to limit it as much as possible:
  (3) Do NOT move a lambda outside a case unless
      (a) The scrutinee is ok-for-speculation, or
      (b) more liberally: the scrutinee is cheap (e.g. a variable), and
-         -fpedantic-bottoms is not enforced (see Trac #2915 for an example)
+         -fpedantic-bottoms is not enforced (see #2915 for an example)
 
 Of course both (1) and (2) are readily defeated by disguising the bottoms.
 
@@ -381,7 +381,7 @@ See also Id.isOneShotBndr.
 Note [State hack and bottoming functions]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 It's a terrible idea to use the state hack on a bottoming function.
-Here's what happens (Trac #2861):
+Here's what happens (#2861):
 
   f :: String -> IO T
   f = \p. error "..."
@@ -410,7 +410,7 @@ Extrude g1.g3
 And now we can repeat the whole loop.  Aargh!  The bug is in applying the
 state hack to a function which then swallows the argument.
 
-This arose in another guise in Trac #3959.  Here we had
+This arose in another guise in #3959.  Here we had
 
      catch# (throw exn >> return ())
 
@@ -590,7 +590,7 @@ says it has arity "infinity" the first time round.
 
 This example happens a lot; it first showed up in Andy Gill's thesis,
 fifteen years ago!  It also shows up in the code for 'rnf' on lists
-in Trac #4138.
+in #4138.
 
 The analysis is easy to achieve because exprEtaExpandArity takes an
 argument
@@ -726,7 +726,7 @@ arityType env (Cast e co)
     -- See Note [exprArity invariant] (2); must be true of
     -- arityType too, since that is how we compute the arity
     -- of variables, and they in turn affect result of exprArity
-    -- Trac #5441 is a nice demo
+    -- #5441 is a nice demo
     -- However, do make sure that ATop -> ATop and ABot -> ABot!
     --   Casts don't affect that part. Getting this wrong provoked #5475
 
index 18e109a..4674b21 100644 (file)
@@ -346,14 +346,14 @@ orphNamesOfTyCon tycon = unitNameSet (getName tycon) `unionNameSet` case tyConCl
 
 orphNamesOfType :: Type -> NameSet
 orphNamesOfType ty | Just ty' <- coreView ty = orphNamesOfType ty'
-                -- Look through type synonyms (Trac #4912)
+                -- Look through type synonyms (#4912)
 orphNamesOfType (TyVarTy _)          = emptyNameSet
 orphNamesOfType (LitTy {})           = emptyNameSet
 orphNamesOfType (TyConApp tycon tys) = orphNamesOfTyCon tycon
                                        `unionNameSet` orphNamesOfTypes tys
 orphNamesOfType (ForAllTy bndr res)  = orphNamesOfType (binderType bndr)
                                        `unionNameSet` orphNamesOfType res
-orphNamesOfType (FunTy _ arg res)    = unitNameSet funTyConName    -- NB!  See Trac #8535
+orphNamesOfType (FunTy _ arg res)    = unitNameSet funTyConName    -- NB!  See #8535
                                        `unionNameSet` orphNamesOfType arg
                                        `unionNameSet` orphNamesOfType res
 orphNamesOfType (AppTy fun arg)      = orphNamesOfType fun `unionNameSet` orphNamesOfType arg
index 62ddb9f..c29c113 100644 (file)
@@ -373,7 +373,7 @@ interactiveInScope :: HscEnv -> [Var]
 -- When we are not in GHCi, the interactive context (hsc_IC hsc_env) is empty
 -- so this is a (cheap) no-op.
 --
--- See Trac #8215 for an example
+-- See #8215 for an example
 interactiveInScope hsc_env
   = tyvars ++ ids
   where
@@ -806,7 +806,7 @@ lintCoreExpr e@(Case scrut var alt_ty alts) =
      ; checkL (not $ isFloatingTy scrut_ty && any isLitPat alts)
          (ptext (sLit $ "Lint warning: Scrutinising floating-point " ++
                         "expression with literal pattern in case " ++
-                        "analysis (see Trac #9238).")
+                        "analysis (see #9238).")
           $$ text "scrut" <+> ppr scrut)
 
      ; case tyConAppTyCon_maybe (idType var) of
@@ -927,7 +927,7 @@ checkJoinOcc var n_args
 Note [No alternatives lint check]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Case expressions with no alternatives are odd beasts, and it would seem
-like they would worth be looking at in the linter (cf Trac #10180). We
+like they would worth be looking at in the linter (cf #10180). We
 used to check two things:
 
 * exprIsHNF is false: it would *seem* to be terribly wrong if
@@ -937,7 +937,7 @@ used to check two things:
   scrutinee is diverging for sure.
 
 It was already known that the second test was not entirely reliable.
-Unfortunately (Trac #13990), the first test turned out not to be reliable
+Unfortunately (#13990), the first test turned out not to be reliable
 either. Getting the checks right turns out to be somewhat complicated.
 
 For example, suppose we have (comment 8)
@@ -1395,7 +1395,7 @@ lintType (CoercionTy co)
 
 {- Note [Stupid type synonyms]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider (Trac #14939)
+Consider (#14939)
    type Alg cls ob = ob
    f :: forall (cls :: * -> Constraint) (b :: Alg cls *). b
 
@@ -1572,18 +1572,18 @@ lintCoreRule fun fun_ty rule@(Rule { ru_name = name, ru_bndrs = bndrs
 It's very bad if simplifying a rule means that one of the template
 variables (ru_bndrs) that /is/ mentioned on the RHS becomes
 not-mentioned in the LHS (ru_args).  How can that happen?  Well, in
-Trac #10602, SpecConstr stupidly constructed a rule like
+#10602, SpecConstr stupidly constructed a rule like
 
   forall x,c1,c2.
      f (x |> c1 |> c2) = ....
 
 But simplExpr collapses those coercions into one.  (Indeed in
-Trac #10602, it collapsed to the identity and was removed altogether.)
+#10602, it collapsed to the identity and was removed altogether.)
 
 We don't have a great story for what to do here, but at least
 this check will nail it.
 
-NB (Trac #11643): it's possible that a variable listed in the
+NB (#11643): it's possible that a variable listed in the
 binders becomes not-mentioned on both LHS and RHS.  Here's a silly
 example:
    RULE forall x y. f (g x y) = g (x+1) (y-1)
@@ -2088,7 +2088,7 @@ type WarnsAndErrs = (Bag MsgDoc, Bag MsgDoc)
 {- Note [Checking for global Ids]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Before CoreTidy, all locally-bound Ids must be LocalIds, even
-top-level ones. See Note [Exported LocalIds] and Trac #9857.
+top-level ones. See Note [Exported LocalIds] and #9857.
 
 Note [Checking StaticPtrs]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -2124,7 +2124,7 @@ Note [Linting type synonym applications]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 When linting a type-synonym, or type-family, application
   S ty1 .. tyn
-we behave as follows (Trac #15057, #T15664):
+we behave as follows (#15057, #T15664):
 
 * If lf_report_unsat_syns = True, and S has arity < n,
   complain about an unsaturated type synonym or type family
index 3d06934..d50dcbf 100644 (file)
@@ -133,7 +133,7 @@ Note [Empty case alternatives]
 * For a key (Case e b ty []) we MUST look at the return type 'ty', because
   otherwise (Case (error () "urk") _ Int  []) would compare equal to
             (Case (error () "urk") _ Bool [])
-  which is utterly wrong (Trac #6097)
+  which is utterly wrong (#6097)
 
 We could compare the return type regardless, but the wildly common case
 is that it's unnecessary, so we have two fields (cm_case and cm_ecase)
index d0dba81..0f7f5fb 100644 (file)
@@ -312,7 +312,7 @@ simple_app env (Tick t e) as
 -- The let might appear there as a result of inlining
 -- e.g.   let f = let x = e in b
 --        in f a1 a2
--- (Trac #13208)
+-- (#13208)
 simple_app env (Let bind body) as
   = case simple_opt_bind env bind of
       (env', Nothing)   -> simple_app env' body as
@@ -490,7 +490,7 @@ rhss here.
 Note [Preserve join-binding arity]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Be careful /not/ to eta-reduce the RHS of a join point, lest we lose
-the join-point arity invariant.  Trac #15108 was caused by simplifying
+the join-point arity invariant.  #15108 was caused by simplifying
 the RHS with simple_opt_expr, which does eta-reduction.  Solution:
 simplify the RHS of a join point by simplifying under the lambdas
 (which of course should be there).
@@ -710,7 +710,7 @@ A more common case is when
 
    f = \x. error ".."
 
-and again its arity increses (Trac #15517)
+and again its arity increses (#15517)
 -}
 
 {- *********************************************************************
@@ -759,7 +759,7 @@ dealWithStringLiteral.
 
 Note [Push coercions in exprIsConApp_maybe]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-In Trac #13025 I found a case where we had
+In #13025 I found a case where we had
     op (df @t1 @t2)     -- op is a ClassOp
 where
     df = (/\a b. K e1 e2) |> g
@@ -1181,7 +1181,7 @@ pushCoTyArg :: CoercionR -> Type -> Maybe (Type, MCoercionR)
 -- it's faster not to compute it, though.
 pushCoTyArg co ty
   -- The following is inefficient - don't do `eqType` here, the coercion
-  -- optimizer will take care of it. See Trac #14737.
+  -- optimizer will take care of it. See #14737.
   -- -- | tyL `eqType` tyR
   -- -- = Just (ty, Nothing)
 
@@ -1219,7 +1219,7 @@ pushCoValArg :: CoercionR -> Maybe (Coercion, MCoercion)
 -- the returned coercion would have been reflexive.
 pushCoValArg co
   -- The following is inefficient - don't do `eqType` here, the coercion
-  -- optimizer will take care of it. See Trac #14737.
+  -- optimizer will take care of it. See #14737.
   -- -- | tyL `eqType` tyR
   -- -- = Just (mkRepReflCo arg, Nothing)
 
index cf37a8d..bf6182b 100644 (file)
@@ -344,7 +344,7 @@ partial applications. But it's easier to let them through.
 
 Note [Dead code in CorePrep]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Imagine that we got an input program like this (see Trac #4962):
+Imagine that we got an input program like this (see #4962):
 
   f :: Show b => Int -> (Int, b -> Maybe Int -> Int)
   f x = (g True (Just x) + g () (Just x), g)
@@ -790,7 +790,7 @@ data ArgInfo = CpeApp  CoreArg
 ~~~~~~~~~~~~~~~~~~~
 If we got, say
    runRW# (case bot of {})
-which happened in Trac #11291, we do /not/ want to turn it into
+which happened in #11291, we do /not/ want to turn it into
    (case bot of {}) realWorldPrimId#
 because that gives a panic in CoreToStg.myCollectArgs, which expects
 only variables in function position.  But if we are sure to make
@@ -1051,7 +1051,7 @@ Note [Floating unlifted arguments]
 Consider    C (let v* = expensive in v)
 
 where the "*" indicates "will be demanded".  Usually v will have been
-inlined by now, but let's suppose it hasn't (see Trac #2756).  Then we
+inlined by now, but let's suppose it hasn't (see #2756).  Then we
 do *not* want to get
 
      let v* = expensive in C v
@@ -1183,7 +1183,7 @@ tryEtaReducePrep bndrs (Let bind@(NonRec _ r) body)
 -- Otherwise we risk reducing
 --       \x. (Tick (Breakpoint {x}) f x)
 --   ==> Tick (breakpoint {x}) f
--- which is bogus (Trac #17228)
+-- which is bogus (#17228)
 -- tryEtaReducePrep bndrs (Tick tickish e)
 --   = fmap (mkTick tickish) $ tryEtaReducePrep bndrs e
 
index 2df3fb1..8ba2e68 100644 (file)
@@ -718,7 +718,7 @@ substTickish _subst other = other
 The functions that substitute over IdInfo must be pretty lazy, because
 they are knot-tied by substRecBndrs.
 
-One case in point was Trac #10627 in which a rule for a function 'f'
+One case in point was #10627 in which a rule for a function 'f'
 referred to 'f' (at a different type) on the RHS.  But instead of just
 substituting in the rhs of the rule, we were calling simpleOptExpr, which
 looked at the idInfo for 'f'; result <<loop>>.
index c4fedbb..f48fef5 100644 (file)
@@ -233,7 +233,7 @@ These data types are the heart of the compiler
 --       can't be @Red@ at that program point.
 --
 --    5. Floating-point values must not be scrutinised against literals.
---       See Trac #9238 and Note [Rules for floating-point comparisons]
+--       See #9238 and Note [Rules for floating-point comparisons]
 --       in PrelRules for rationale.
 --
 -- *  Cast an expression to a particular type.
@@ -338,7 +338,7 @@ Note [Literal alternatives]
 Literal alternatives (LitAlt lit) are always for *un-lifted* literals.
 We have one literal, a literal Integer, that is lifted, and we don't
 allow in a LitAlt, because LitAlt cases don't do any evaluation. Also
-(see Trac #5603) if you say
+(see #5603) if you say
     case 3 of
       S# x -> ...
       J# _ _ -> ...
@@ -348,7 +348,7 @@ literals are an opaque encoding of an algebraic data type, not of
 an unlifted literal, like all the others.
 
 Also, we do not permit case analysis with literal patterns on floating-point
-types. See Trac #9238 and Note [Rules for floating-point comparisons] in
+types. See #9238 and Note [Rules for floating-point comparisons] in
 PrelRules for the rationale for this restriction.
 
 -------------------------- CoreSyn INVARIANTS ---------------------------
@@ -386,7 +386,7 @@ Consider,
 
 In order to be able to inline `f`, we would like to float `a` to the top.
 Another option would be to inline `a`, but that would lead to duplicating string
-literals, which we want to avoid. See Trac #8472.
+literals, which we want to avoid. See #8472.
 
 The solution is simply to allow top-level unlifted binders. We can't allow
 arbitrary unlifted expression at the top-level though, unlifted binders cannot
@@ -395,7 +395,7 @@ be thunks, so we just allow string literals.
 We allow the top-level primitive string literals to be wrapped in Ticks
 in the same way they can be wrapped when nested in an expression.
 CoreToSTG currently discards Ticks around top-level primitive string literals.
-See Trac #14779.
+See #14779.
 
 Also see Note [Compilation plan for top-level string literals].
 
@@ -518,7 +518,7 @@ this exhaustive list can be empty!
   we do NOT want to replace
     case (x::T) of Bool {}   -->   error Bool "Inaccessible case"
   because x might raise an exception, and *that*'s what we want to see!
-  (Trac #6067 is an example.) To preserve semantics we'd have to say
+  (#6067 is an example.) To preserve semantics we'd have to say
      x `seq` error Bool "Inaccessible case"
   but the 'seq' is just a case, so we are back to square 1.  Or I suppose
   we could say
@@ -626,7 +626,7 @@ However, join points have simpler invariants in other ways
 
   6. A join point can have a levity-polymorphic RHS
      e.g.  let j :: r :: TYPE l = fail void# in ...
-     This happened in an intermediate program Trac #13394
+     This happened in an intermediate program #13394
 
 Examples:
 
@@ -1113,7 +1113,7 @@ chooseOrphanAnchor :: NameSet -> IsOrphan
 -- Something (rule, instance) is relate to all the Names in this
 -- list. Choose one of them to be an "anchor" for the orphan.  We make
 -- the choice deterministic to avoid gratuitious changes in the ABI
--- hash (Trac #4012).  Specifically, use lexicographic comparison of
+-- hash (#4012).  Specifically, use lexicographic comparison of
 -- OccName rather than comparing Uniques
 --
 -- NB: 'minimum' use Ord, and (Ord OccName) works lexicographically
@@ -1641,7 +1641,7 @@ ones are
 
    OtherCon {}    If we know this binder (say a lambda binder) will be
                   bound to an evaluated thing, we want to retain that
-                  info in simpleOptExpr; see Trac #13077.
+                  info in simpleOptExpr; see #13077.
 
 We consider even a StableUnfolding as fragile, because it needs substitution.
 
index e55e124..1e4e39e 100644 (file)
@@ -260,7 +260,7 @@ the `UnfoldingGuidance`.)
 
 In the example, x's ug_arity is 0, so we should inline it at every use
 site.  It's rare to have such an INLINE pragma (usually INLINE Is on
-functions), but it's occasionally very important (Trac #15578, #15519).
+functions), but it's occasionally very important (#15578, #15519).
 In #15519 we had something like
    x = case (g a b) of I# r -> T r
    {-# INLINE x #-}
@@ -357,7 +357,7 @@ But given this decision it's vital that we do
 where g* is (for some strange reason) the loop breaker.  If we don't
 occ-anal it when reading it in, we won't mark g as a loop breaker, and
 we may inline g entirely in body, dropping its binding, and leaving
-the occurrence in f out of scope. This happened in Trac #8892, where
+the occurrence in f out of scope. This happened in #8892, where
 the unfolding in question was a DFun unfolding.
 
 But more generally, the simplifier is designed on the
@@ -395,7 +395,7 @@ GlobalIds.  That seems (just) tolerable for the occurrence analysis that happens
 just before the Simplifier, but not for unfoldings, which are Linted
 independently.
 As a quick workaround, we disable binder swap in this module.
-See Trac #16288 and #16296 for further plans.
+See #16288 and #16296 for further plans.
 
 Note [Calculate unfolding guidance on the non-occ-anal'd expression]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -910,7 +910,7 @@ Simon M tried a MUCH bigger discount: (10 * (10 + n_val_args)),
 and said it was an "unambiguous win", but its terribly dangerous
 because a function with many many case branches, each finishing with
 a constructor, can have an arbitrarily large discount.  This led to
-terrible code bloat: see Trac #6099.
+terrible code bloat: see #6099.
 
 Note [Unboxed tuple size and result discount]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -936,10 +936,10 @@ monadic combinators with continuation arguments, where inlining is
 quite important.
 
 But we don't want a big discount when a function is called many times
-(see the detailed comments with Trac #6048) because if the function is
+(see the detailed comments with #6048) because if the function is
 big it won't be inlined at its many call sites and no benefit results.
 Indeed, we can get exponentially big inlinings this way; that is what
-Trac #6048 is about.
+#6048 is about.
 
 On the other hand, for data-valued arguments, if there are lots of
 case expressions in the body, each one will get smaller if we apply
@@ -1170,7 +1170,7 @@ certainlyWillInline dflags fn_info
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Don't claim that thunks will certainly inline, because that risks work
 duplication.  Even if the work duplication is not great (eg is_cheap
-holds), it can make a big difference in an inner loop In Trac #5623 we
+holds), it can make a big difference in an inner loop In #5623 we
 found that the WorkWrap phase thought that
        y = case x of F# v -> F# (v +# v)
 was certainlyWillInline, so the addition got duplicated.
index 5b16199..8e298ad 100644 (file)
@@ -190,7 +190,7 @@ not much used, except in the output of the desugarer.
 Example:
      let a = Int in (\x:a. x)
 Given this, exprType must be careful to substitute 'a' in the
-result type (Trac #8522).
+result type (#8522).
 
 Note [Existential variables and silly type synonyms]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -202,7 +202,7 @@ Consider
 
 Now, the type of 'x' is (Funny a), where 'a' is existentially quantified.
 That means that 'exprType' and 'coreAltsType' may give a result that *appears*
-to mention an out-of-scope type variable.  See Trac #3409 for a more real-world
+to mention an out-of-scope type variable.  See #3409 for a more real-world
 example.
 
 Various possibilities suggest themselves:
@@ -571,7 +571,7 @@ that cannot match.  For example:
 
 Suppose that for some silly reason, x isn't substituted in the case
 expression.  (Perhaps there's a NOINLINE on it, or profiling SCC stuff
-gets in the way; cf Trac #3118.)  Then the full-lazines pass might produce
+gets in the way; cf #3118.)  Then the full-lazines pass might produce
 this
 
      x = Red
@@ -827,11 +827,11 @@ and similarly in cascade for all the join points!
 NB: it's important that all this is done in [InAlt], *before* we work
 on the alternatives themselves, because Simplify.simplAlt may zap the
 occurrence info on the binders in the alternatives, which in turn
-defeats combineIdenticalAlts (see Trac #7360).
+defeats combineIdenticalAlts (see #7360).
 
 Note [Care with impossible-constructors when combining alternatives]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Suppose we have (Trac #10538)
+Suppose we have (#10538)
    data T = A | B | C | D
 
       case x::T of   (Imposs-default-cons {A,B})
@@ -867,7 +867,7 @@ Then when combining the A and C alternatives we get
 
 Note that we have a new DEFAULT branch that we didn't have before.  So
 we need delete from the "impossible-default-constructors" all the
-known-con alternatives that we have eliminated. (In Trac #11172 we
+known-con alternatives that we have eliminated. (In #11172 we
 missed the first one.)
 
 -}
@@ -950,7 +950,7 @@ it as trivial we may land up with let-bindings like
    let v = case x of {} in ...
 and after CoreToSTG that gives
    let v = x in ...
-and that confuses the code generator (Trac #11155). So best to kill
+and that confuses the code generator (#11155). So best to kill
 it off at source.
 -}
 
@@ -1102,7 +1102,7 @@ dupAppSize :: Int
 dupAppSize = 8   -- Size of term we are prepared to duplicate
                  -- This is *just* big enough to make test MethSharing
                  -- inline enough join points.  Really it should be
-                 -- smaller, and could be if we fixed Trac #4960.
+                 -- smaller, and could be if we fixed #4960.
 
 {-
 ************************************************************************
@@ -1116,7 +1116,7 @@ Note [exprIsWorkFree]
 exprIsWorkFree is used when deciding whether to inline something; we
 don't inline it if doing so might duplicate work, by peeling off a
 complete copy of the expression.  Here we do not want even to
-duplicate a primop (Trac #5623):
+duplicate a primop (#5623):
    eg   let x = a #+ b in x +# x
    we do not want to inline/duplicate x
 
@@ -1276,7 +1276,7 @@ expansion.  Specifically:
 
 * False of case-expressions.  If we have
     let x = case ... in ...(case x of ...)...
-  we won't simplify.  We have to inline x.  See Trac #14688.
+  we won't simplify.  We have to inline x.  See #14688.
 
 * False of let-expressions (same reason); and in any case we
   float lets out of an RHS if doing so will reveal an expandable
@@ -1657,7 +1657,7 @@ But we restrict it sharply:
   add unlifted algebraic types in due course.
 
 
------ Historical note: Trac #15696: --------
+----- Historical note: #15696: --------
   Previously SetLevels used exprOkForSpeculation to guide
   floating of single-alternative cases; it now uses exprIsHNF
   Note [Floating single-alternative cases].
@@ -1676,9 +1676,9 @@ But we restrict it sharply:
     ...(case x of y
             A -> ...
             _ -> ...blah...)...
-  which is utterly bogus (seg fault); see Trac #5453.
+  which is utterly bogus (seg fault); see #5453.
 
------ Historical note: Trac #3717: --------
+----- Historical note: #3717: --------
     foo :: Int -> Int
     foo 0 = 0
     foo n = (if n < 5 then 1 else 2) `seq` foo (n-1)
@@ -1703,7 +1703,7 @@ points do the job nicely.
 
 Note [Primops with lifted arguments]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Is this ok-for-speculation (see Trac #13027)?
+Is this ok-for-speculation (see #13027)?
    reallyUnsafePtrEq# a b
 Well, yes.  The primop accepts lifted arguments and does not
 evaluate them.  Indeed, in general primops are, well, primitive
@@ -2279,7 +2279,7 @@ There are some particularly delicate points here:
   *keeps* arity 1 (perhaps also wrongly).  So CorePrep eta-expands
   the definition again, so that it does not termninate after all.
   Result: seg-fault because the boolean case actually gets a function value.
-  See Trac #1947.
+  See #1947.
 
   So it's important to do the right thing.
 
@@ -2434,7 +2434,7 @@ to the rule that
   * f is not bottom
 we can eta-reduce    \x. f x  ===>  f
 
-This turned up in Trac #7542.
+This turned up in #7542.
 
 
 ************************************************************************
index 999cfc7..f9609f8 100644 (file)
@@ -840,7 +840,7 @@ used, and does a w/w split thus
 After some simplification, the (absentError "blah") thunk goes away.
 
 ------ Tricky wrinkle -------
-Trac #14285 had, roughly
+#14285 had, roughly
 
    data T a = MkT a !a
    {-# INLINABLE f #-}
index 81832c8..db3a501 100644 (file)
@@ -1030,7 +1030,7 @@ translatePat fam_insts pat = case pat of
     --
     --     - Otherwise, we treat the `ListPat` as ordinary view pattern.
     --
-    -- See Trac #14547, especially comment#9 and comment#10.
+    -- See #14547, especially comment#9 and comment#10.
     --
     -- Here we construct CanFailPmPat directly, rather can construct a view
     -- pattern and do further translation as an optimization, for the reason,
@@ -1100,7 +1100,7 @@ from translation in pattern matcher.
     `HsOverLit` inside `NPat` to HsIntPrim/HsWordPrim. If we do
     the same thing in `translatePat` as in `tidyNPat`, the exhaustiveness
     checker will fail to match the literals patterns correctly. See
-    Trac #14546.
+    #14546.
 
   In Note [Undecidable Equality for Overloaded Literals], we say: "treat
   overloaded literals that look different as different", but previously we
@@ -1121,7 +1121,7 @@ from translation in pattern matcher.
     in value position as PmOLit, but translate the 0 and 1 in pattern position
     as PmSLit. The inconsistency leads to the failure of eqPmLit to detect the
     equality and report warning of "Pattern match is redundant" on pattern 0,
-    as reported in Trac #14546. In this patch we remove the specialization of
+    as reported in #14546. In this patch we remove the specialization of
     OverLit patterns, and keep the overloaded number literal in pattern as it
     is to maintain the consistency. We know nothing about the `fromInteger`
     method (see Note [Undecidable Equality for Overloaded Literals]). Now we
@@ -1141,7 +1141,7 @@ from translation in pattern matcher.
     non-overloaded string values are translated to PmSLit. However the string
     patterns, both overloaded and non-overloaded, are translated to list of
     characters. The inconsistency leads to wrong warnings about redundant and
-    non-exhaustive pattern matching warnings, as reported in Trac #14546.
+    non-exhaustive pattern matching warnings, as reported in #14546.
 
     In order to catch the redundant pattern in following case:
 
@@ -1167,7 +1167,7 @@ from translation in pattern matcher.
 
   We must ensure that doing the same translation to literal values and patterns
   in `translatePat` and `hsExprToPmExpr`. The previous inconsistent work led to
-  Trac #14546.
+  #14546.
 -}
 
 -- | Translate a list of patterns (Note: each pattern is translated
@@ -2511,7 +2511,7 @@ dsPmWarn dflags ctx@(DsMatchContext kind loc) pm_result
 
 {- Note [Inaccessible warnings for record updates]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider (Trac #12957)
+Consider (#12957)
   data T a where
     T1 :: { x :: Int } -> T Bool
     T2 :: { x :: Int } -> T a
index aa9748e..128722d 100644 (file)
@@ -533,7 +533,7 @@ by 'competesWith'
 
 Class methods have a built-in RULE to select the method from the dictionary,
 so you can't change the phase on this.  That makes id very dubious to
-match on class methods in RULE lhs's.   See Trac #10595.   I'm not happy
+match on class methods in RULE lhs's.   See #10595.   I'm not happy
 about this. For example in Control.Arrow we have
 
 {-# RULES "compose/arr"   forall f g .
index d62706e..cf94a5e 100644 (file)
@@ -776,7 +776,7 @@ we might have
 
 We might want to specialise 'f' so that we in turn specialise '$wf'.
 We can't even /name/ '$wf' in the source code, so we can't specialise
-it even if we wanted to.  Trac #10721 is a case in point.
+it even if we wanted to.  #10721 is a case in point.
 
 Note [Activation pragmas for SPECIALISE]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -792,7 +792,7 @@ We need two pragma-like things:
 * Activation of RULE: from SPECIALISE pragma (if activation given)
                       otherwise from f's inline pragma
 
-This is not obvious (see Trac #5237)!
+This is not obvious (see #5237)!
 
 Examples      Rule activation   Inline prag on spec'd fn
 ---------------------------------------------------------------------
@@ -875,7 +875,7 @@ decomposeRuleLhs dflags orig_bndrs orig_lhs
                            , not (v `elemVarSet` orig_bndr_set)
                            , not (v == fn_id) ]
          -- fn_id: do not quantify over the function itself, which may
-         -- itself be a dictionary (in pathological cases, Trac #10251)
+         -- itself be a dictionary (in pathological cases, #10251)
 
    decompose (Var fn_id) args
       | not (fn_id `elemVarSet` orig_bndr_set)
@@ -1018,7 +1018,7 @@ drop_dicts drops dictionary bindings on the LHS where possible.
 
     NB3: In the common case of a non-overloaded, but perhaps-polymorphic
          specialisation, we don't need to bind *any* dictionaries for use
-         in the RHS. For example (Trac #8331)
+         in the RHS. For example (#8331)
              {-# SPECIALIZE INLINE useAbstractMonad :: ReaderST s Int #-}
              useAbstractMonad :: MonadAbstractIOST m => m Int
          Here, deriving (MonadAbstractIOST (ReaderST s)) is a lot of code
@@ -1026,7 +1026,7 @@ drop_dicts drops dictionary bindings on the LHS where possible.
              RULE forall s (d :: MonadAbstractIOST (ReaderT s)).
                 useAbstractMonad (ReaderT s) d = $suseAbstractMonad s
 
-   Trac #8848 is a good example of where there are some interesting
+   #8848 is a good example of where there are some interesting
    dictionary bindings to discard.
 
 The drop_dicts algorithm is based on these observations:
index c6ba18b..89ca815 100644 (file)
@@ -122,7 +122,7 @@ ds_val_bind (NonRecursive, hsbinds) body
             -- f x = let p@(Ptr y) = ... in ...
             -- Here the binding for 'p' is polymorphic, but does
             -- not mix with an unlifted binding for 'y'.  You should
-            -- use a bang pattern.  Trac #6078.
+            -- use a bang pattern.  #6078.
 
     else do { when (looksLazyPatBind bind) $
               warnIfSetDs Opt_WarnUnbangedStrictPatterns (unlifted_must_be_bang bind)
@@ -622,7 +622,7 @@ ds_expr _ expr@(RecordUpd { rupd_expr = record_expr, rupd_flds = fields
       -- Clone the Id in the HsRecField, because its Name is that
       -- of the record selector, and we must not make that a local binder
       -- else we shadow other uses of the record selector
-      -- Hence 'lcl_id'.  Cf Trac #2735
+      -- Hence 'lcl_id'.  Cf #2735
     ds_field (dL->L _ rec_field)
       = do { rhs <- dsLExpr (hsRecFieldArg rec_field)
            ; let fld_id = unLoc (hsRecUpdFieldId rec_field)
index 2aaafad..5de954a 100644 (file)
@@ -524,7 +524,7 @@ repClsInstD (ClsInstDecl { cid_poly_ty = ty, cid_binds = binds
             -- But we do NOT bring the binders of 'binds' into scope
             -- because they are properly regarded as occurrences
             -- For example, the method names should be bound to
-            -- the selector Ids, not to fresh names (Trac #5410)
+            -- the selector Ids, not to fresh names (#5410)
             --
             do { cxt1     <- repLContext cxt
                ; inst_ty1 <- repLTy inst_ty
index f328322..8e3021f 100644 (file)
@@ -486,7 +486,7 @@ askNoErrsDs thing_inside
       ; env <- getGblEnv
       ; mb_res <- tryM $  -- Be careful to catch exceptions
                           -- so that we propagate errors correctly
-                          -- (Trac #13642)
+                          -- (#13642)
                   setGblEnv (env { ds_msgs = errs_var }) $
                   thing_inside
 
index a6b94c9..7c8e24b 100644 (file)
@@ -50,7 +50,7 @@ In this case, B's dep_orphs will contain A due to its SOURCE import of A.
 Consequently, A will contain itself in its imp_orphs due to its import of B.
 This fact would end up being recorded in A's interface file. This would then
 break the invariant asserted by calculateAvails that a module does not itself in
-its dep_orphs. This was the cause of Trac #14128.
+its dep_orphs. This was the cause of #14128.
 
 -}
 
index f39d0f2..d4ceb52 100644 (file)
@@ -411,7 +411,7 @@ mkErrorAppDs err_id ty msg = do
 {-
 'mkCoreAppDs' and 'mkCoreAppsDs' hand the special-case desugaring of 'seq'.
 
-Note [Desugaring seq (1)]  cf Trac #1031
+Note [Desugaring seq (1)]  cf #1031
 ~~~~~~~~~~~~~~~~~~~~~~~~~
    f x y = x `seq` (y `seq` (# x,y #))
 
@@ -427,7 +427,7 @@ But that is bad for two reasons:
 Seq is very, very special!  So we recognise it right here, and desugar to
         case x of _ -> case y of _ -> (# x,y #)
 
-Note [Desugaring seq (2)]  cf Trac #2273
+Note [Desugaring seq (2)]  cf #2273
 ~~~~~~~~~~~~~~~~~~~~~~~~~
 Consider
    let chp = case b of { True -> fst x; False -> 0 }
@@ -467,7 +467,7 @@ And now all is well.
 The reason it's a hack is because if you define mySeq=seq, the hack
 won't work on mySeq.
 
-Note [Desugaring seq (3)] cf Trac #2409
+Note [Desugaring seq (3)] cf #2409
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 The isLocalId ensures that we don't turn
         True `seq` e
@@ -879,7 +879,7 @@ Reason: we know that a failure point is always a "join point" and is
 entered at most once.  Adding a dummy 'realWorld' token argument makes
 it clear that sharing is not an issue.  And that in turn makes it more
 CPR-friendly.  This matters a lot: if you don't get it right, you lose
-the tail call property.  For example, see Trac #3403.
+the tail call property.  For example, see #3403.
 
 
 ************************************************************************
index 0930a6e..c057298 100644 (file)
@@ -154,7 +154,7 @@ Most of the matching functions take an Id or [Id] as argument.  This Id
 is the scrutinee(s) of the match. The desugared expression may
 sometimes use that Id in a local binding or as a case binder.  So it
 should not have an External name; Lint rejects non-top-level binders
-with External names (Trac #13043).
+with External names (#13043).
 
 See also Note [Localise pattern binders] in DsUtils
 -}
@@ -515,7 +515,7 @@ tidy_bang_pat v o _ p@(SumPat {})    = tidy1 v o p
 tidy_bang_pat v o l p@(ConPatOut { pat_con = (dL->L _ (RealDataCon dc))
                                  , pat_args = args
                                  , pat_arg_tys = arg_tys })
-  -- Newtypes: push bang inwards (Trac #9844)
+  -- Newtypes: push bang inwards (#9844)
   =
     if isNewTyCon (dataConTyCon dc)
       then tidy1 v o (p { pat_args = push_bang_into_newtype_arg l ty args })
@@ -534,7 +534,7 @@ tidy_bang_pat v o l p@(ConPatOut { pat_con = (dL->L _ (RealDataCon dc))
 --    NPlusKPat
 --
 -- For LazyPat, remember that it's semantically like a VarPat
---  i.e.  !(~p) is not like ~p, or p!  (Trac #8952)
+--  i.e.  !(~p) is not like ~p, or p!  (#8952)
 --
 -- NB: SigPatIn, ConPatIn should not happen
 
@@ -568,7 +568,7 @@ Note [Bang patterns and newtypes]
 For the pattern  !(Just pat)  we can discard the bang, because
 the pattern is strict anyway. But for !(N pat), where
   newtype NT = N Int
-we definitely can't discard the bang.  Trac #9844.
+we definitely can't discard the bang.  #9844.
 
 So what we do is to push the bang inwards, in the hope that it will
 get discarded there.  So we transform
@@ -926,7 +926,7 @@ If we see
     ...
 where P is a pattern synonym, can we put (P a -> e1) and (P b -> e2) in the
 same group?  We can if P is a constructor, but /not/ if P is a pattern synonym.
-Consider (Trac #11224)
+Consider (#11224)
    -- readMaybe :: Read a => String -> Maybe a
    pattern PRead :: Read a => () => a -> String
    pattern PRead a <- (readMaybe -> Just a)
index f699792..ce1f19f 100644 (file)
@@ -242,7 +242,7 @@ Consider
          f (T { y=True, x=False }) = ...
 
 We must match the patterns IN THE ORDER GIVEN, thus for the first
-one we match y=True before x=False.  See Trac #246; or imagine
+one we match y=True before x=False.  See #246; or imagine
 matching against (T { y=False, x=undefined }): should fail without
 touching the undefined.
 
index d0db91d..d99ae7e 100644 (file)
@@ -287,7 +287,7 @@ warnAboutEmptyEnumerations dflags fromExpr mThnExpr toExpr
 
 getLHsIntegralLit :: LHsExpr GhcTc -> Maybe (Integer, Name)
 -- ^ See if the expression is an 'Integral' literal.
--- Remember to look through automatically-added tick-boxes! (Trac #8384)
+-- Remember to look through automatically-added tick-boxes! (#8384)
 getLHsIntegralLit (dL->L _ (HsPar _ e))            = getLHsIntegralLit e
 getLHsIntegralLit (dL->L _ (HsTick _ _ e))         = getLHsIntegralLit e
 getLHsIntegralLit (dL->L _ (HsBinTick _ _ _ e))    = getLHsIntegralLit e
@@ -349,7 +349,7 @@ tidyNPat (OverLit (OverLitTc False ty) val _) mb_neg _eq outer_ty
         -- Once that is settled, look for cases where the type of the
         -- entire overloaded literal matches the type of the underlying literal,
         -- and in that case take the short cut
-        -- NB: Watch out for weird cases like Trac #3382
+        -- NB: Watch out for weird cases like #3382
         --        f :: Int -> Int
         --        f "blah" = 4
         --     which might be ok if we have 'instance IsString Int'
@@ -363,7 +363,7 @@ tidyNPat (OverLit (OverLitTc False ty) val _) mb_neg _eq outer_ty
      -- NB: do /not/ convert Float or Double literals to F# 3.8 or D# 5.3
      -- If we do convert to the constructor form, we'll generate a case
      -- expression on a Float# or Double# and that's not allowed in Core; see
-     -- Trac #9238 and Note [Rules for floating-point comparisons] in PrelRules
+     -- #9238 and Note [Rules for floating-point comparisons] in PrelRules
   where
     -- Sometimes (like in test case
     -- overloadedlists/should_run/overloadedlistsrun04), the SyntaxExprs include
index 86bb72b..c4a08c4 100644 (file)
@@ -614,7 +614,7 @@ schemeE d s p exp@(AnnTick (Breakpoint _id _fvs) _rhs)
           -- type and hence won't be bound in the environment, but the
           -- breakpoint will otherwise work fine.
           --
-          -- NB (Trac #12007) this /also/ applies for if (ty :: TYPE r), where
+          -- NB (#12007) this /also/ applies for if (ty :: TYPE r), where
           --    r :: RuntimeRep is a variable. This can happen in the
           --    continuations for a pattern-synonym matcher
           --    match = /\(r::RuntimeRep) /\(a::TYPE r).
@@ -962,7 +962,7 @@ doCase d s p (_,scrut) bndr alts is_unboxed_tuple
                 return (my_discr alt, rhs_code)
            -- If an alt attempts to match on an unboxed tuple or sum, we must
            -- bail out, as the bytecode compiler can't handle them.
-           -- (See Trac #14608.)
+           -- (See #14608.)
            | any (\bndr -> typePrimRep (idType bndr) `lengthExceeds` 1) bndrs
            = multiValException
            -- algebraic alt with some binders
@@ -1398,7 +1398,7 @@ to have an info-table, and the next word to have the value to be
 tested.  This is very weird, but it's the way it is right now.  See
 Interpreter.c.  We don't acutally need an info-table here; we just
 need to have the argument to be one-from-top on the stack, hence pushing
-a 1-word null. See Trac #8383.
+a 1-word null. See #8383.
 -}
 
 
@@ -1825,7 +1825,7 @@ atomPrimRep e | Just e' <- bcView e = atomPrimRep e'
 atomPrimRep (AnnVar v)              = bcIdPrimRep v
 atomPrimRep (AnnLit l)              = typePrimRep1 (literalType l)
 
--- Trac #12128:
+-- #12128:
 -- A case expression can be an atom because empty cases evaluate to bottom.
 -- See Note [Empty case alternatives] in coreSyn/CoreSyn.hs
 atomPrimRep (AnnCase _ _ ty _)      = ASSERT(typePrimRep ty == [LiftedRep]) LiftedRep
index dad13b7..ef00a85 100644 (file)
@@ -341,7 +341,7 @@ linkCmdLineLibs' hsc_env pls =
       -- However because we don't know the actual name of pthread's dll we
       -- need to defer this to the locateLib call so we can't initialize it
       -- inside of the rts. Instead we do it here to be able to find the
-      -- import library for pthreads. See Trac #13210.
+      -- import library for pthreads. See #13210.
       let platform = targetPlatform dflags
           os       = platformOS platform
           minus_ls = case os of
index 82e0f88..436b756 100644 (file)
@@ -1056,7 +1056,7 @@ getDataConArgTys dc con_app_ty
 
 {- Note [Constructor arg types]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider a GADT (cf Trac #7386)
+Consider a GADT (cf #7386)
    data family D a b
    data instance D [a] a where
      MkT :: a -> D [a] (Maybe a)
index 7113905..77ffebe 100644 (file)
@@ -1570,7 +1570,7 @@ points so that the code is readable with its original meaning.
 
 So scattered through Convert.hs are various points where parens are added.
 
-See (among other closed issued) https://ghc.haskell.org/trac/ghc/ticket/14289
+See (among other closed issued) https://gitlab.haskell.org/ghc/ghc/issues/14289
 -}
 -- ---------------------------------------------------------------------
 
@@ -1730,7 +1730,7 @@ mkHsForAllTy tvs loc fvf tvs' rho_ty
 
 -- It's important that we don't build an HsQualTy if the context is empty,
 -- as the pretty-printer for HsType _always_ prints contexts, even if
--- they're empty. See Trac #13183.
+-- they're empty. See #13183.
 mkHsQualTy :: TH.Cxt
            -- ^ The original Template Haskell context
            -> SrcSpan
@@ -1820,7 +1820,7 @@ thRdrName :: SrcSpan -> OccName.NameSpace -> String -> TH.NameFlavour -> RdrName
 --
 -- We pass in a SrcSpan (gotten from the monad) because this function
 -- is used for *binders* and if we make an Exact Name we want it
--- to have a binding site inside it.  (cf Trac #5434)
+-- to have a binding site inside it.  (cf #5434)
 --
 -- ToDo: we may generate silly RdrNames, by passing a name space
 --       that doesn't match the string, like VarName ":+",
@@ -1842,7 +1842,7 @@ thRdrName loc ctxt_ns th_occ th_name
     occ = mk_occ ctxt_ns th_occ
 
 -- Return an unqualified exact RdrName if we're dealing with built-in syntax.
--- See Trac #13776.
+-- See #13776.
 thOrigRdrName :: String -> TH.NameSpace -> PkgName -> ModName -> RdrName
 thOrigRdrName occ th_ns pkg mod =
   let occ' = mk_occ (mk_ghc_ns th_ns) occ
index 110c0fb..8e3448d 100644 (file)
@@ -549,7 +549,7 @@ case we'd prefer to generate the (more direct)
      (# fromInteger $dNum 3, fromInteger $dNum 4 #)
 
 A similar thing happens with representation-polymorphic defns
-(Trac #11405):
+(#11405):
 
   undef :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
   undef = error "undef"
@@ -798,7 +798,7 @@ instance (idR ~ GhcPass pr,OutputableBndrId idL, OutputableBndrId idR,
 
 pprTicks :: SDoc -> SDoc -> SDoc
 -- Print stuff about ticks only when -dppr-debug is on, to avoid
--- them appearing in error messages (from the desugarer); see Trac # 3263
+-- them appearing in error messages (from the desugarer); see # 3263
 -- Also print ticks in dumpStyle, so that -ddump-hpc actually does
 -- something useful.
 pprTicks pp_no_debug pp_when_debug
index f8709fb..d4742f5 100644 (file)
@@ -855,7 +855,7 @@ NOTE THAT
     not be bound after it.)
 
     This last point is much more debatable than the others; see
-    Trac #15142 comment:22
+    #15142 comment:22
 -}
 
 
index 37d7182..bd63150 100644 (file)
@@ -247,7 +247,7 @@ When it calls RnEnv.unknownNameSuggestions to identify these alternatives, the
 typechecker must provide a GlobalRdrEnv.  If it provided the current one, which
 contains top-level declarations for the entire module, the error message would
 incorrectly suggest the out-of-scope `bar` and `bad` as possible alternatives
-for `bar` (see Trac #11680).  Instead, the typechecker must use the same
+for `bar` (see #11680).  Instead, the typechecker must use the same
 GlobalRdrEnv the renamer used when it determined that `bar` is out-of-scope.
 
 To obtain this GlobalRdrEnv, can the typechecker simply use the out-of-scope
@@ -2012,7 +2012,7 @@ Note [The type of bind in Stmts]
 Some Stmts, notably BindStmt, keep the (>>=) bind operator.
 We do NOT assume that it has type
     (>>=) :: m a -> (a -> m b) -> m b
-In some cases (see Trac #303, #1537) it might have a more
+In some cases (see #303, #1537) it might have a more
 exotic type, such as
     (>>=) :: m i j a -> (a -> m j k b) -> m i k b
 So we must be careful not to make assumptions about the type.
@@ -2306,7 +2306,7 @@ pprComp quals     -- Prints:  body | qual1, ..., qualn
        -- one, we simply treat it like a normal list. This does arise
        -- occasionally in code that GHC generates, e.g., in implementations of
        -- 'range' for derived 'Ix' instances for product datatypes with exactly
-       -- one constructor (e.g., see Trac #12583).
+       -- one constructor (e.g., see #12583).
        then ppr body
        else hang (ppr body <+> vbar) 2 (pprQuals initStmts)
   | otherwise
index 91be149..bce65ba 100644 (file)
@@ -292,7 +292,7 @@ type instance XParPat  (GhcPass _) = NoExt
 type instance XBangPat (GhcPass _) = NoExt
 
 -- Note: XListPat cannot be extended when using GHC 8.0.2 as the bootstrap
--- compiler, as it triggers https://ghc.haskell.org/trac/ghc/ticket/14396 for
+-- compiler, as it triggers https://gitlab.haskell.org/ghc/ghc/issues/14396 for
 -- `SyntaxExpr`
 type instance XListPat GhcPs = NoExt
 type instance XListPat GhcRn = Maybe (SyntaxExpr GhcRn)
@@ -735,7 +735,7 @@ isIrrefutableHsPat
                            =
       isJust (tyConSingleDataCon_maybe (dataConTyCon con))
       -- NB: tyConSingleDataCon_maybe, *not* isProductTyCon, because
-      -- the latter is false of existentials. See Trac #4439
+      -- the latter is false of existentials. See #4439
       && all goL (hsConPatArgs details)
     go (ConPatOut
         { pat_con = (dL->L _ (PatSynCon _pat)) })
index ba961b5..9bb73c3 100644 (file)
@@ -213,7 +213,7 @@ Note carefully:
   Or even:
         f :: forall _a. _a -> _b
   Here _a is an ordinary forall'd binder, but (With NamedWildCards)
-  _b is a named wildcard.  (See the comments in Trac #10982)
+  _b is a named wildcard.  (See the comments in #10982)
 
 * Named wildcards are bound by the HsWildCardBndrs construct, which wraps
   types that are allowed to have wildcards. Unnamed wildcards however are left
@@ -757,7 +757,7 @@ After renaming
 Qualified currently behaves exactly as Implicit,
 but it is deprecated to use it for implicit quantification.
 In this case, GHC 7.10 gives a warning; see
-Note [Context quantification] in RnTypes, and Trac #4426.
+Note [Context quantification] in RnTypes, and #4426.
 In GHC 8.0, Qualified will no longer bind variables
 and this will become an error.
 
@@ -1065,7 +1065,7 @@ mkHsAppKindTy ext ty k
 -- Breaks up any parens in the result type:
 --      splitHsFunType (a -> (b -> c)) = ([a,b], c)
 -- Also deals with (->) t1 t2; that is why it only works on LHsType Name
---   (see Trac #9096)
+--   (see #9096)
 splitHsFunType :: LHsType GhcRn -> ([LHsType GhcRn], LHsType GhcRn)
 splitHsFunType (L _ (HsParTy _ ty))
   = splitHsFunType ty
@@ -1483,7 +1483,7 @@ pprConDeclFields fields = braces (sep (punctuate comma (map ppr_fld fields)))
 {-
 Note [Printing KindedTyVars]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Trac #3830 reminded me that we should really only print the kind
+#3830 reminded me that we should really only print the kind
 signature on a KindedTyVar if the kind signature was put there by the
 programmer.  During kind inference GHC now adds a PostTcKind to UserTyVars,
 rather than converting to KindedTyVars as before.
index 62c153e..fa8ec14 100644 (file)
@@ -611,7 +611,7 @@ mkHsSigEnv get_info sigs
    `extendNameEnvList` (mk_pairs gen_dm_sigs)
    -- The subtlety is this: in a class decl with a
    -- default-method signature as well as a method signature
-   -- we want the latter to win (Trac #12533)
+   -- we want the latter to win (#12533)
    --    class C x where
    --       op :: forall a . x a -> x a
    --       default op :: forall b . x b -> x b
@@ -693,7 +693,7 @@ typeToLHsType ty
     go (CoercionTy co)      = pprPanic "toLHsSigWcType" (ppr co)
 
          -- Source-language types have _invisible_ kind arguments,
-         -- so we must remove them here (Trac #8563)
+         -- so we must remove them here (#8563)
 
     go_tv :: TyVar -> LHsTyVarBndr GhcPs
     go_tv tv = noLoc $ KindedTyVar noExt (noLoc (getRdrName tv))
@@ -703,7 +703,7 @@ typeToLHsType ty
 Note [Kind signatures in typeToLHsType]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 There are types that typeToLHsType can produce which require explicit kind
-signatures in order to kind-check. Here is an example from Trac #14579:
+signatures in order to kind-check. Here is an example from #14579:
 
   -- type P :: forall {k} {t :: k}. Proxy t
   type P = 'Proxy
@@ -1302,7 +1302,7 @@ main name (the TyCon of a type declaration etc), we want to give it
 the @SrcSpan@ of the whole /declaration/, not just the name itself
 (which is how it appears in the syntax tree).  This SrcSpan (for the
 entire declaration) is used as the SrcSpan for the Name that is
-finally produced, and hence for error messages.  (See Trac #8607.)
+finally produced, and hence for error messages.  (See #8607.)
 
 Note [Binders in family instances]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
index 4cbcb96..dc1c843 100644 (file)
@@ -370,7 +370,7 @@ Consider
 
 We cannot represent this by a newtype, even though it's not
 existential, because there are two value fields (the equality
-predicate and op. See Trac #2238
+predicate and op. See #2238
 
 Moreover,
           class (a ~ F b) => C a b where {}
index 2ef369a..a9ab4c9 100644 (file)
@@ -73,7 +73,7 @@ fingerprintOptFlags :: DynFlags
                       -> IO Fingerprint
 fingerprintOptFlags DynFlags{..} nameio =
       let
-        -- See https://ghc.haskell.org/trac/ghc/ticket/10923
+        -- See https://gitlab.haskell.org/ghc/ghc/issues/10923
         -- We used to fingerprint the optimisation level, but as Joachim
         -- Breitner pointed out in comment 9 on that ticket, it's better
         -- to ignore that and just look at the individual optimisation flags.
@@ -91,7 +91,7 @@ fingerprintHpcFlags :: DynFlags
                       -> IO Fingerprint
 fingerprintHpcFlags dflags@DynFlags{..} nameio =
       let
-        -- -fhpc, see https://ghc.haskell.org/trac/ghc/ticket/11798
+        -- -fhpc, see https://gitlab.haskell.org/ghc/ghc/issues/11798
         -- hpcDir is output-only, so we should recompile if it changes
         hpc = if gopt Opt_Hpc dflags then Just hpcDir else Nothing
 
index 05f64df..b066f5c 100644 (file)
@@ -745,7 +745,7 @@ pprIfaceDecl ss (IfaceData { ifName = tycon, ifCType = ctype,
                                         (occName tycon))
                                     binders roles
             -- Don't display roles for data family instances (yet)
-            -- See discussion on Trac #8672.
+            -- See discussion on #8672.
 
     add_bars []     = Outputable.empty
     add_bars (c:cs) = sep ((equals <+> c) : map (vbar <+>) cs)
index e2235ab..4488aef 100644 (file)
@@ -853,7 +853,7 @@ pretty-printing (defaultRuntimeRepVars, controlled by
 
 This applies to /quantified/ variables like 'w' above.  What about
 variables that are /free/ in the type being printed, which certainly
-happens in error messages.  Suppose (Trac #16074) we are reporting a
+happens in error messages.  Suppose (#16074) we are reporting a
 mismatch between two skolems
           (a :: RuntimeRep) ~ (b :: RuntimeRep)
 We certainly don't want to say "Can't match LiftedRep ~ LiftedRep"!
@@ -1169,7 +1169,7 @@ family instances as Specified.
 
 Note [Printing promoted type constructors]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider this GHCi session (Trac #14343)
+Consider this GHCi session (#14343)
     > _ :: Proxy '[ 'True ]
     error:
       Found hole: _ :: Proxy '['True]
index 927c49b..497ddfc 100644 (file)
@@ -876,7 +876,7 @@ It is possible (though hard) to get this error through user behaviour.
     is a home-package module which is not yet in the HPT!  Disaster.
 
 This actually happened with P=base, Q=ghc-prim, via the AMP warnings.
-See Trac #8320.
+See #8320.
 -}
 
 findAndReadIface :: SDoc
index 1ea608e..440f89f 100644 (file)
@@ -625,7 +625,7 @@ addFingerprints hsc_env mb_old_fingerprint iface0 new_decls
 
    -- Note [Do not update EPS with your own hi-boot]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-   -- (See also Trac #10182).  When your hs-boot file includes an orphan
+   -- (See also #10182).  When your hs-boot file includes an orphan
    -- instance declaration, you may find that the dep_orphs of a module you
    -- import contains reference to yourself.  DO NOT actually load this module
    -- or add it to the orphan hashes: you're going to provide the orphan
@@ -991,7 +991,7 @@ declExtras fix_fn ann_fn rule_env inst_env fi_env dm_env decl
             insts = (map ifDFun $ (concatMap at_extras ats)
                                     ++ lookupOccEnvL inst_env n)
                            -- Include instances of the associated types
-                           -- as well as instances of the class (Trac #5147)
+                           -- as well as instances of the class (#5147)
             meths = [id_extras (getOccName op) | IfaceClassOp op _ _ <- sigs]
             -- Names of all the default methods (see Note [default method Name])
             defms = [ dmName
@@ -1136,7 +1136,7 @@ Note [Internal used_names]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 Most of the used_names are External Names, but we can have Internal
 Names too: see Note [Binders in Template Haskell] in Convert, and
-Trac #5362 for an example.  Such Names are always
+#5362 for an example.  Such Names are always
   - Such Names are always for locally-defined things, for which we
     don't gather usage info, so we can just ignore them in ent_map
   - They are always System Names, hence the assert, just as a double check.
index 3874d8d..732ee1b 100644 (file)
@@ -16,7 +16,7 @@ module TcIface (
         typecheckIfaceForInstantiate,
         tcIfaceDecl, tcIfaceInst, tcIfaceFamInst, tcIfaceRules,
         tcIfaceAnnotations, tcIfaceCompleteSigs,
-        tcIfaceExpr,    -- Desired by HERMIT (Trac #7683)
+        tcIfaceExpr,    -- Desired by HERMIT (#7683)
         tcIfaceGlobal
  ) where
 
@@ -757,7 +757,7 @@ tc_iface_decl _parent ignore_prags
         --     class C (T a) => D a where
         --       data T a
         -- Here the associated type T is knot-tied with the class, and
-        -- so we must not pull on T too eagerly.  See Trac #5970
+        -- so we must not pull on T too eagerly.  See #5970
 
    tc_sig :: IfaceClassOp -> IfL TcMethInfo
    tc_sig (IfaceClassOp op_name rdr_ty dm)
@@ -789,7 +789,7 @@ tc_iface_decl _parent ignore_prags
                                      ; return (Just (tc_def, noSrcSpan)) }
                   -- Must be done lazily in case the RHS of the defaults mention
                   -- the type constructor being defined here
-                  -- e.g.   type AT a; type AT b = AT [b]   Trac #8002
+                  -- e.g.   type AT a; type AT b = AT [b]   #8002
           return (ATI tc mb_def)
 
    mk_sc_doc pred = text "Superclass" <+> ppr pred
@@ -804,7 +804,7 @@ tc_iface_decl _ _ (IfaceAxiom { ifName = tc_name, ifTyCon = tc
        -- a hs-boot declared type constructor that is going to be
        -- defined by this module.
        -- e.g. type instance F Int = ToBeDefined
-       -- See Trac #13803
+       -- See #13803
        ; tc_branches <- forkM (text "Axiom branches" <+> ppr tc_name)
                       $ tc_ax_branches branches
        ; let axiom = CoAxiom { co_ax_unique   = nameUnique tc_name
@@ -992,7 +992,7 @@ Note [Synonym kind loop]
 ~~~~~~~~~~~~~~~~~~~~~~~~
 Notice that we eagerly grab the *kind* from the interface file, but
 build a forkM thunk for the *rhs* (and family stuff).  To see why,
-consider this (Trac #2412)
+consider this (#2412)
 
 M.hs:       module M where { import X; data T = MkT S }
 X.hs:       module X where { import {-# SOURCE #-} M; type S = T }
index 3779e39..aa4e53c 100644 (file)
@@ -322,7 +322,7 @@ toIfaceAppArgsX fr kind ty_args
         -- e.g. kind = k, ty_args = [Int]
         -- This is probably a compiler bug, so we print a trace and
         -- carry on as if it were FunTy.  Without the test for
-        -- isEmptyTCvSubst we'd get an infinite loop (Trac #15473)
+        -- isEmptyTCvSubst we'd get an infinite loop (#15473)
         WARN( True, ppr kind $$ ppr ty_args )
         IA_Arg (toIfaceTypeX fr t1) Required (go env ty ts1)
 
@@ -522,7 +522,7 @@ toIfaceTickish (HpcTick modl ix)       = Just (IfaceHpcTick modl ix)
 toIfaceTickish (SourceNote src names)  = Just (IfaceSource src names)
 toIfaceTickish (Breakpoint {})         = Nothing
    -- Ignore breakpoints, since they are relevant only to GHCi, and
-   -- should not be serialised (Trac #8333)
+   -- should not be serialised (#8333)
 
 ---------------------
 toIfaceBind :: Bind Id -> IfaceBinding
@@ -581,7 +581,7 @@ toIfaceVar v
 
 {- Note [Inlining and hs-boot files]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider this example (Trac #10083, #12789):
+Consider this example (#10083, #12789):
 
     ---------- RSR.hs-boot ------------
     module RSR where
@@ -643,7 +643,7 @@ But how do we arrange for this to happen?  There are two ingredients:
 Here is a solution that doesn't work: when compiling RSR,
 add a NOINLINE pragma to every function exported by the boot-file
 for RSR (if it exists).  Doing so makes the bootstrapped GHC itself
-slower by 8% overall (on Trac #9872a-d, and T1969: the reason
+slower by 8% overall (on #9872a-d, and T1969: the reason
 is that these NOINLINE'd functions now can't be profitably inlined
 outside of the hs-boot loop.
 
index 975c361..9bcceb5 100644 (file)
@@ -231,7 +231,7 @@ ppLit f@(LMFloatLit _ _)       = sdocWithDynFlags (\dflags ->
                                    error $ "Can't print this float literal!" ++ showSDoc dflags (ppr f))
 ppLit (LMVectorLit ls  )       = char '<' <+> ppCommaJoin ls <+> char '>'
 ppLit (LMNullLit _     )       = text "null"
--- Trac 11487 was an issue where we passed undef for some arguments
+-- #11487 was an issue where we passed undef for some arguments
 -- that were actually live. By chance the registers holding those
 -- arguments usually happened to have the right values anyways, but
 -- that was not guaranteed. To find such bugs reliably, we set the
index b003cbc..a24a416 100644 (file)
@@ -138,7 +138,7 @@ cmmDataLlvmGens statics
 -- | LLVM can't handle entry blocks which loop back to themselves (could be
 -- seen as an LLVM bug) so we rearrange the code to keep the original entry
 -- label which branches to a newly generated second label that branches back
--- to itself. See: Trac #11649
+-- to itself. See: #11649
 fixBottom :: RawCmmDecl -> LlvmM RawCmmDecl
 fixBottom cp@(CmmProc hdr entry_lbl live g) =
     maybe (pure cp) fix_block $ mapLookup (g_entry g) blk_map
index 1f1b44e..73292d0 100644 (file)
@@ -106,7 +106,7 @@ getBSDArchEntries = do
                         return $ C.unpack $ C.takeWhile (/= ' ') name
         off2    <- liftM fromIntegral bytesRead :: Get Int
         file    <- getByteString (st_size - (off2 - off1))
-        -- data sections are two byte aligned (see Trac #15396)
+        -- data sections are two byte aligned (see #15396)
         when (odd st_size) $
           void (getByteString 1)
 
@@ -135,7 +135,7 @@ getGNUArchEntries extInfo = do
         fail ("[BSD Archive] Invalid archive header end marker for name: " ++
               C.unpack name)
       file <- getByteString st_size
-      -- data sections are two byte aligned (see Trac #15396)
+      -- data sections are two byte aligned (see #15396)
       when (odd st_size) $
         void (getByteString 1)
       name <- return . C.unpack $
index cb30b6f..6763aed 100644 (file)
@@ -235,12 +235,12 @@ processOneArg opt_kind rest arg args
                                     []               -> missingArgErr dash_arg
                                     (L _ arg1:args1) -> Right (f arg1, args1)
 
-        -- See Trac #9776
+        -- See #9776
         SepArg f -> case args of
                         []               -> missingArgErr dash_arg
                         (L _ arg1:args1) -> Right (f arg1, args1)
 
-        -- See Trac #12625
+        -- See #12625
         Prefix f | notNull rest_no_eq -> Right (f rest_no_eq, args)
                  | otherwise          -> missingArgErr  dash_arg
 
@@ -277,7 +277,7 @@ arg_ok (NoArg           _)  rest _   = null rest
 arg_ok (HasArg          _)  _    _   = True
 arg_ok (SepArg          _)  rest _   = null rest
 arg_ok (Prefix          _)  _    _   = True -- Missing argument checked for in processOneArg t
-                                            -- to improve error message (Trac #12625)
+                                            -- to improve error message (#12625)
 arg_ok (OptIntSuffix    _)  _    _   = True
 arg_ok (IntSuffix       _)  _    _   = True
 arg_ok (FloatSuffix     _)  _    _   = True
index 7eda130..cf34585 100644 (file)
@@ -26,7 +26,7 @@ mAX_SUM_SIZE :: Int
 mAX_SUM_SIZE = 62
 
 -- | Default maximum depth for both class instance search and type family
--- reduction. See also Trac #5395.
+-- reduction. See also #5395.
 mAX_REDUCTION_DEPTH :: Int
 mAX_REDUCTION_DEPTH = 200
 
index 9989287..5866568 100644 (file)
@@ -329,7 +329,7 @@ compileEmptyStub dflags hsc_env basename location mod_name = do
   -- valid) stub object file for signatures.  However,
   -- we make sure this object file has a unique symbol,
   -- so that ranlib on OS X doesn't complain, see
-  -- http://ghc.haskell.org/trac/ghc/ticket/12673
+  -- https://gitlab.haskell.org/ghc/ghc/issues/12673
   -- and https://github.com/haskell/cabal/issues/2257
   empty_stub <- newTempName dflags TFL_CurrentModule "c"
   let src = text "int" <+> ppr (mkModule (thisPackage dflags) mod_name) <+> text "= 0;"
@@ -777,7 +777,7 @@ getOutputFilename stop_phase output basename dflags next_phase maybe_location
                        As _    | keep_s     -> True
                        LlvmOpt | keep_bc    -> True
                        HCc     | keep_hc    -> True
-                       HsPp _  | keep_hscpp -> True   -- See Trac #10869
+                       HsPp _  | keep_hscpp -> True   -- See #10869
                        _other               -> False
 
           suffix = myPhaseInputExt next_phase
@@ -1958,7 +1958,7 @@ doCpp dflags raw input_fn output_fn = do
                     -- Include version macros for every *exposed* package.
                     -- Without -hide-all-packages and with a package database
                     -- size of 1000 packages, it takes cpp an estimated 2
-                    -- milliseconds to process this file. See Trac #10970
+                    -- milliseconds to process this file. See #10970
                     -- comment 8.
                     return [SysTools.FileOption "-include" macro_stub]
             else return []
@@ -2011,7 +2011,7 @@ getBackendDefs _ =
 
 generatePackageVersionMacros :: [PackageConfig] -> String
 generatePackageVersionMacros pkgs = concat
-  -- Do not add any C-style comments. See Trac #3389.
+  -- Do not add any C-style comments. See #3389.
   [ generateMacros "" pkgname version
   | pkg <- pkgs
   , let version = packageVersion pkg
index b3cfa48..ba4cfe7 100644 (file)
@@ -324,7 +324,7 @@ import Foreign (Ptr) -- needed for 2nd stage
 --    There is a change log tracking language extension additions and removals
 --    on the GHC wiki:  https://ghc.haskell.org/trac/ghc/wiki/LanguagePragmaHistory
 --
---  See Trac #4437 and #8176.
+--  See #4437 and #8176.
 
 -- -----------------------------------------------------------------------------
 -- DynFlags
@@ -727,7 +727,7 @@ data WarnReason
 
 -- | Used to differentiate the scope an include needs to apply to.
 -- We have to split the include paths to avoid accidentally forcing recursive
--- includes since -I overrides the system search paths. See Trac #14312.
+-- includes since -I overrides the system search paths. See #14312.
 data IncludeSpecs
   = IncludeSpecs { includePathsQuote  :: [String]
                  , includePathsGlobal :: [String]
@@ -3005,7 +3005,7 @@ dynamic_flags_deps = [
   , make_ord_flag defFlag "pgmc"
       (hasArg (\f -> alterSettings (\s -> s { sPgm_c   = (f,[]),
                                               -- Don't pass -no-pie with -pgmc
-                                              -- (see Trac #15319)
+                                              -- (see #15319)
                                               sGccSupportsNoPie = False})))
   , make_ord_flag defFlag "pgms"
       (HasArg (\_ -> addWarn "Object splitting was removed in GHC 8.8"))
@@ -3753,7 +3753,7 @@ dynamic_flags_deps = [
                   "-XDeriveGeneric for generic programming support.") ]
 
 -- | This is where we handle unrecognised warning flags. We only issue a warning
--- if -Wunrecognised-warning-flags is set. See Trac #11429 for context.
+-- if -Wunrecognised-warning-flags is set. See #11429 for context.
 unrecognisedWarning :: String -> Flag (CmdLineP DynFlags)
 unrecognisedWarning prefix = defHiddenFlag prefix (Prefix action)
   where
@@ -4557,7 +4557,7 @@ impliedXFlags
     , (LangExt.ExistentialQuantification, turnOn, LangExt.ExplicitForAll)
     , (LangExt.FlexibleInstances,         turnOn, LangExt.TypeSynonymInstances)
     , (LangExt.FunctionalDependencies,    turnOn, LangExt.MultiParamTypeClasses)
-    , (LangExt.MultiParamTypeClasses,     turnOn, LangExt.ConstrainedClassMethods)  -- c.f. Trac #7854
+    , (LangExt.MultiParamTypeClasses,     turnOn, LangExt.ConstrainedClassMethods)  -- c.f. #7854
     , (LangExt.TypeFamilyDependencies,    turnOn, LangExt.TypeFamilies)
 
     , (LangExt.RebindableSyntax, turnOff, LangExt.ImplicitPrelude)      -- NB: turn off!
@@ -4675,7 +4675,7 @@ optLevelFlags -- see Note [Documenting optimisation flags]
 
 {- Note [Eta-reduction in -O0]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Trac #11562 showed an example which tripped an ASSERT in CoreToStg; a
+#11562 showed an example which tripped an ASSERT in CoreToStg; a
 function was marked as MayHaveCafRefs when in fact it obviously
 didn't.  Reason was:
  * Eta reduction wasn't happening in the simplifier, but it was
@@ -5553,7 +5553,7 @@ picCCOpts dflags = pieOpts ++ picOpts
        | gopt Opt_PIC dflags || WayDyn `elem` ways dflags ->
           ["-fPIC", "-U__PIC__", "-D__PIC__"]
       -- gcc may be configured to have PIC on by default, let's be
-      -- explicit here, see Trac #15847
+      -- explicit here, see #15847
        | otherwise -> ["-fno-PIC"]
 
     pieOpts
index 9ee6856..4f19437 100644 (file)
@@ -485,7 +485,7 @@ withDumpFileHandle dflags flag action = do
             -- We do not want the dump file to be affected by
             -- environment variables, but instead to always use
             -- UTF8. See:
-            -- https://ghc.haskell.org/trac/ghc/ticket/10762
+            -- https://gitlab.haskell.org/ghc/ghc/issues/10762
             hSetEncoding handle utf8
 
             action (Just handle)
index 9e58f35..4e6e0f4 100644 (file)
@@ -138,7 +138,7 @@ module GHC (
         getDocs, GetDocsFailure(..),
 
         -- ** Other
-        runTcInteractive,   -- Desired by some clients (Trac #8878)
+        runTcInteractive,   -- Desired by some clients (#8878)
         isStmt, hasImport, isImport, isDecl,
 
         -- ** The debugger
@@ -516,7 +516,7 @@ initGhcMonad mb_top_dir
 -- check should be more selective but there is currently no released
 -- version where this bug is fixed.
 -- See https://sourceware.org/bugzilla/show_bug.cgi?id=16177 and
--- https://ghc.haskell.org/trac/ghc/ticket/4210#comment:29
+-- https://gitlab.haskell.org/ghc/ghc/issues/4210#note_78333
 checkBrokenTablesNextToCode :: MonadIO m => DynFlags -> m ()
 checkBrokenTablesNextToCode dflags
   = do { broken <- checkBrokenTablesNextToCode' dflags
index a6fe5c7..d730fe7 100644 (file)
@@ -160,7 +160,7 @@ depanal excluded_mods allow_dup_roots = do
 -- but "A" imports some other module "C", then GHC will issue a warning
 -- about module "C" not being listed in a command line.
 --
--- The warning in enabled by `-Wmissing-home-modules`. See Trac #13129
+-- The warning in enabled by `-Wmissing-home-modules`. See #13129
 warnMissingHomeModules :: GhcMonad m => HscEnv -> ModuleGraph -> m ()
 warnMissingHomeModules hsc_env mod_graph =
     when (wopt Opt_WarnMissingHomeModules dflags && not (null missing)) $
@@ -178,7 +178,7 @@ warnMissingHomeModules hsc_env mod_graph =
     -- For instance, `ghc --make src-exe/Main.hs` and
     -- `ghc --make -isrc-exe Main` are supposed to be equivalent.
     -- Note also that we can't always infer the associated module name
-    -- directly from the filename argument.  See Trac #13727.
+    -- directly from the filename argument.  See #13727.
     is_my_target mod (TargetModule name)
       = moduleName (ms_mod mod) == name
     is_my_target mod (TargetFile target_file _)
@@ -868,7 +868,7 @@ parUpsweep n_jobs mHscMessage old_hpt stable_mods cleanup sccs = do
             n_cpus <- getNumProcessors
             -- Setting number of capabilities more than
             -- CPU count usually leads to high userspace
-            -- lock contention. Trac #9221
+            -- lock contention. #9221
             let n_caps = min n_jobs n_cpus
             unless (n_capabilities /= 1) $ setNumCapabilities n_caps
             return n_capabilities
@@ -1629,7 +1629,7 @@ Potential TODOS:
 -- be any object code that we can compare against, nor should there
 -- be: we're *just* generating interface files.  In this case, we
 -- want to check if the interface file is new, in lieu of the object
--- file.  See also Trac #9243.
+-- file.  See also #9243.
 
 -- Filter modules in the HPT
 retainInTopLevelEnvs :: [ModuleName] -> HomePackageTable -> HomePackageTable
index 0ca7bda..add0ee9 100644 (file)
@@ -703,7 +703,7 @@ hptSomeThingsBelowUs extract include_hi_boot hsc_env deps
                     Nothing -> pprTrace "WARNING in hptSomeThingsBelowUs" msg []
           msg = vcat [text "missing module" <+> ppr mod,
                       text "Probable cause: out-of-date interface files"]
-                        -- This really shouldn't happen, but see Trac #962
+                        -- This really shouldn't happen, but see #962
 
         -- And get its dfuns
     , thing <- things ]
@@ -1535,7 +1535,7 @@ e.g.    Prelude> data T = A | B
         Prelude> instance Eq T where ...
         Prelude> instance Eq T where ...   -- This one overrides
 
-It's exactly the same for type-family instances.  See Trac #7102
+It's exactly the same for type-family instances.  See #7102
 -}
 
 -- | Interactive context, recording information about the state of the
@@ -1658,7 +1658,7 @@ extendInteractiveContext :: InteractiveContext
 extendInteractiveContext ictxt new_tythings new_cls_insts new_fam_insts defaults fix_env
   = ictxt { ic_mod_index  = ic_mod_index ictxt + 1
                             -- Always bump this; even instances should create
-                            -- a new mod_index (Trac #9426)
+                            -- a new mod_index (#9426)
           , ic_tythings   = new_tythings ++ old_tythings
           , ic_rn_gbl_env = ic_rn_gbl_env ictxt `icExtendGblRdrEnv` new_tythings
           , ic_instances  = ( new_cls_insts ++ old_cls_insts
@@ -1726,7 +1726,7 @@ icExtendGblRdrEnv env tythings
     -- are not implicit-ids, and must appear in the TypeEnv.  But they
     -- will also be brought into scope by the corresponding (ATyCon
     -- tc).  And we want the latter, because that has the correct
-    -- parent (Trac #10520)
+    -- parent (#10520)
     is_sub_bndr (AnId f) = case idDetails f of
                              RecSelId {}  -> True
                              ClassOpId {} -> True
index 5ff1b03..2c04029 100644 (file)
@@ -249,7 +249,7 @@ Things like the coercion axiom for newtypes. These bindings all get
 OccNames that users can't write, to avoid the possibility of name
 clashes (in linker symbols).  That gives a convenient way to suppress
 them. The relevant predicate is OccName.isDerivedOccName.
-See Trac #11051 for more background and examples.
+See #11051 for more background and examples.
 -}
 
 withVirtualCWD :: GhcMonad m => m a -> m a
@@ -756,7 +756,7 @@ moduleIsInterpreted modl = withSession $ \h ->
 -- Filter the instances by the ones whose tycons (or clases resp)
 -- are in scope (qualified or otherwise).  Otherwise we list a whole lot too many!
 -- The exact choice of which ones to show, and which to hide, is a judgement call.
---      (see Trac #1581)
+--      (see #1581)
 getInfo :: GhcMonad m => Bool -> Name
         -> m (Maybe (TyThing,Fixity,[ClsInst],[FamInst], SDoc))
 getInfo allInfo name
@@ -800,7 +800,7 @@ getRdrNamesInScope = withSession $ \hsc_env -> do
       ic = hsc_IC hsc_env
       gbl_rdrenv = ic_rn_gbl_env ic
       gbl_names = concatMap greRdrNames $ globalRdrEnvElts gbl_rdrenv
-  -- Exclude internally generated names; see e.g. Trac #11328
+  -- Exclude internally generated names; see e.g. #11328
   return (filter (not . isDerivedOccName . rdrNameOcc) gbl_names)
 
 
index 44258de..8c81d82 100644 (file)
@@ -1723,7 +1723,7 @@ mkUnusableModuleToPkgConfAll unusables =
 -- | Add a list of key/value pairs to a nested map.
 --
 -- The outer map is processed with 'Data.Map.Strict' to prevent memory leaks
--- when reloading modules in GHCi (see Trac #4029). This ensures that each
+-- when reloading modules in GHCi (see #4029). This ensures that each
 -- value is forced before installing into the map.
 addListTo :: (Monoid a, Ord k1, Ord k2)
           => Map k1 (Map k2 a)
index 543dd9c..fddc4ac 100644 (file)
@@ -314,7 +314,7 @@ initSysTools top_dir
 
 {- Note [Windows stack usage]
 
-See: Trac #8870 (and #8834 for related info) and #12186
+See: #8870 (and #8834 for related info) and #12186
 
 On Windows, occasionally we need to grow the stack. In order to do
 this, we would normally just bump the stack pointer - but there's a
@@ -616,5 +616,5 @@ R_*_COPY relocations.
 Unregisterised compiler can't evade R_*_COPY relocations easily thus we disable
 -Bsymbolic linking there.
 
-See related Trac tickets: #4210, #15338
+See related tickets: #4210, #15338
 -}
index 420a2bf..2dcd395 100644 (file)
@@ -26,7 +26,7 @@ import SysTools.Process
 
 {- Note [Run-time linker info]
 
-See also: Trac #5240, Trac #6063, Trac #10110
+See also: #5240, #6063, #10110
 
 Before 'runLink', we need to be sure to get the relevant information
 about the linker we're using at runtime to see if we need any extra
@@ -127,8 +127,8 @@ getLinkerInfo' dflags = do
       parseLinkerInfo stdo _stde _exitc
         | any ("GNU ld" `isPrefixOf`) stdo =
           -- GNU ld specifically needs to use less memory. This especially
-          -- hurts on small object files. Trac #5240.
-          -- Set DT_NEEDED for all shared libraries. Trac #10110.
+          -- hurts on small object files. #5240.
+          -- Set DT_NEEDED for all shared libraries. #10110.
           -- TODO: Investigate if these help or hurt when using split sections.
           return (GnuLD $ map Option ["-Wl,--hash-size=31",
                                       "-Wl,--reduce-memory-overheads",
@@ -137,7 +137,7 @@ getLinkerInfo' dflags = do
                                       "-Wl,--no-as-needed"])
 
         | any ("GNU gold" `isPrefixOf`) stdo =
-          -- GNU gold only needs --no-as-needed. Trac #10110.
+          -- GNU gold only needs --no-as-needed. #10110.
           -- ELF specific flag, see Note [ELF needed shared libs]
           return (GnuGold [Option "-Wl,--no-as-needed"])
 
index cc8f67d..2e0e502 100644 (file)
@@ -117,7 +117,7 @@ runSomething dflags phase_name pgm args =
 -- response files for passing them in. See:
 --
 --     https://gcc.gnu.org/wiki/Response_Files
---     https://ghc.haskell.org/trac/ghc/ticket/10777
+--     https://gitlab.haskell.org/ghc/ghc/issues/10777
 runSomethingResponseFile
   :: DynFlags -> (String->String) -> String -> String -> [Option]
   -> Maybe [(String,String)] -> IO ()
index e9f3f85..6e84530 100644 (file)
@@ -486,7 +486,7 @@ extendTypeEnvWithPatSyns tidy_patsyns type_env
 Note [Don't attempt to trim data types]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 For some time GHC tried to avoid exporting the data constructors
-of a data type if it wasn't strictly necessary to do so; see Trac #835.
+of a data type if it wasn't strictly necessary to do so; see #835.
 But "strictly necessary" accumulated a longer and longer list
 of exceptions, and finally I gave up the battle:
 
@@ -501,7 +501,7 @@ of exceptions, and finally I gave up the battle:
     there are a lot of exceptions, notably when Template Haskell is
     involved or, more recently, DataKinds.
 
-    However Trac #7445 shows that even without TemplateHaskell, using
+    However #7445 shows that even without TemplateHaskell, using
     the Data class and invoking Language.Haskell.TH.Quote.dataToExpQ
     is enough to require us to expose the data constructors.
 
@@ -528,7 +528,7 @@ Then the unfolding looks like
 This generates bad code unless it's first simplified a bit.  That is
 why CoreUnfold.mkImplicitUnfolding uses simpleOptExpr to do a bit of
 optimisation first.  (Only matters when the selector is used curried;
-eg map x ys.)  See Trac #2070.
+eg map x ys.)  See #2070.
 
 [Oct 09: in fact, record selectors are no longer implicit Ids at all,
 because we really do want to optimise them properly. They are treated
@@ -541,7 +541,7 @@ because GlobalIds are supposed to have *fixed* IdInfo, but the
 simplifier and other core-to-core passes mess with IdInfo all the
 time.  The straw that broke the camels back was when a class selector
 got the wrong arity -- ie the simplifier gave it arity 2, whereas
-importing modules were expecting it to have arity 1 (Trac #2844).
+importing modules were expecting it to have arity 1 (#2844).
 It's much safer just to inject them right at the end, after tidying.
 
 Oh: two other reasons for injecting them late:
@@ -1251,7 +1251,7 @@ tidyTopIdInfo dflags rhs_tidy_env name orig_rhs tidy_rhs idinfo show_unfold caf_
     --     marked NOINLINE or something like that
     -- This is important: if you expose the worker for a loop-breaker
     -- then you can make the simplifier go into an infinite loop, because
-    -- in effect the unfolding is exposed.  See Trac #1709
+    -- in effect the unfolding is exposed.  See #1709
     --
     -- You might think that if show_unfold is False, then the thing should
     -- not be w/w'd in the first place.  But a legitimate reason is this:
@@ -1371,7 +1371,7 @@ not exported, to reduce the size of interface files, at least without
 -O.  But that is not always possible: see the old Note [When we can't
 trim types] below for exceptions.
 
-Then (Trac #7445) I realised that the TH problem arises for any data type
+Then (#7445) I realised that the TH problem arises for any data type
 that we have deriving( Data ), because we can invoke
    Language.Haskell.TH.Quote.dataToExpQ
 to get a TH Exp representation of a value built from that data type.
@@ -1396,7 +1396,7 @@ now.
 
 But there are some times we can't do that, indicated by the 'no_trim_types' flag.
 
-First, Template Haskell.  Consider (Trac #2386) this
+First, Template Haskell.  Consider (#2386) this
         module M(T, makeOne) where
           data T = Yay String
           makeOne = [| Yay "Yep" |]
@@ -1405,7 +1405,7 @@ A module that splices in $(makeOne) will then look for a declaration of Yay,
 so it'd better be there.  Hence, brutally but simply, we switch off type
 constructor trimming if TH is enabled in this module.
 
-Second, data kinds.  Consider (Trac #5912)
+Second, data kinds.  Consider (#5912)
      {-# LANGUAGE DataKinds #-}
      module M() where
      data UnaryTypeC a = UnaryDataC a
index c9d5c2d..c4eb081 100644 (file)
@@ -754,12 +754,12 @@ pprInstr (SR II32 reg1 reg2 (RIImm (ImmInt i))) | i < 0  || i > 31 =
     -- Handle the case where we are asked to shift a 32 bit register by
     -- less than zero or more than 31 bits. We convert this into a clear
     -- of the destination register.
-    -- Fixes ticket http://ghc.haskell.org/trac/ghc/ticket/5900
+    -- Fixes ticket https://gitlab.haskell.org/ghc/ghc/issues/5900
     pprInstr (XOR reg1 reg2 (RIReg reg2))
 
 pprInstr (SL II32 reg1 reg2 (RIImm (ImmInt i))) | i < 0  || i > 31 =
     -- As above for SR, but for left shifts.
-    -- Fixes ticket http://ghc.haskell.org/trac/ghc/ticket/10870
+    -- Fixes ticket https://gitlab.haskell.org/ghc/ghc/issues/10870
     pprInstr (XOR reg1 reg2 (RIReg reg2))
 
 pprInstr (SRA II32 reg1 reg2 (RIImm (ImmInt i))) | i > 31 =
index 84f9492..80f3e61 100644 (file)
@@ -103,7 +103,7 @@ pprASCII :: ByteString -> SDoc
 pprASCII str
   -- Transform this given literal bytestring to escaped string and construct
   -- the literal SDoc directly.
-  -- See Trac #14741
+  -- See #14741
   -- and Note [Pretty print ASCII when AsmCodeGen]
   = text $ BS.foldr (\w s -> do1 w ++ s) "" str
     where
@@ -189,7 +189,7 @@ high memory usage.
 Now we escape the given bytestring to string directly and construct
 SDoc only once. This improvement could dramatically decrease the
 memory allocation from 4.7GB to 1.3GB when embedding a 3MB literal
-string in source code. See Trac #14741 for profiling results.
+string in source code. See #14741 for profiling results.
 -}
 
 -- ----------------------------------------------------------------------------
index 2d099f9..6ecd4cd 100644 (file)
@@ -726,7 +726,7 @@ pprInstr (TEST format src dst) = sdocWithPlatform $ \platform ->
         -- The mask must have the high bit clear for this smaller encoding
         -- to be completely equivalent to the original; in particular so
         -- that the signed comparison condition bits are the same as they
-        -- would be if doing a full word comparison. See Trac #13425.
+        -- would be if doing a full word comparison. See #13425.
         (OpImm (ImmInteger mask), OpReg dstReg)
           | 0 <= mask && mask < 128 -> minSizeOfReg platform dstReg
         _ -> format
index d77564e..7c08cea 100644 (file)
@@ -1884,7 +1884,7 @@ lex_quasiquote start s = do
 
     -- NB: The string "|]" terminates the quasiquote,
     -- with absolutely no escaping. See the extensive
-    -- discussion on Trac #5348 for why there is no
+    -- discussion on #5348 for why there is no
     -- escape handling.
     Just ('|',i)
         | Just (']',i) <- alexGetChar' i
index 739090f..ed326eb 100644 (file)
@@ -3269,7 +3269,7 @@ fbind   :: { LHsRecField GhcPs (LHsExpr GhcPs) }
         : qvar '=' texp {% runExpCmdP $3 >>= \ $3 ->
                            ams  (sLL $1 $> $ HsRecField (sL1 $1 $ mkFieldOcc $1) $3 False)
                                 [mj AnnEqual $2] }
-                        -- RHS is a 'texp', allowing view patterns (Trac #6038)
+                        -- RHS is a 'texp', allowing view patterns (#6038)
                         -- and, incidentally, sections.  Eg
                         -- f (R { x = show -> s }) = ...
 
@@ -3960,7 +3960,7 @@ warnSpaceAfterBang span = do
 
 -- When two single quotes don't followed by tyvar or gtycon, we report the
 -- error as empty character literal, or TH quote that missing proper type
--- variable or constructor. See Trac #13450.
+-- variable or constructor. See #13450.
 reportEmptyDoubleQuotes :: SrcSpan -> P a
 reportEmptyDoubleQuotes span = do
     thQuotes <- getBit ThQuotesBit
index 480b730..2fd47ac 100644 (file)
@@ -1304,7 +1304,7 @@ checkValSigLhs lhs@(dL->L l _)
          = "Should be of form <variable> :: <type>"
 
     -- A common error is to forget the ForeignFunctionInterface flag
-    -- so check for that, and suggest.  cf Trac #3805
+    -- so check for that, and suggest.  cf #3805
     -- Sadly 'foreign import' still barfs 'parse error' because
     --  'import' is a keyword
     looks_like s (dL->L _ (HsVar _ (dL->L _ v))) = v == s
@@ -2132,7 +2132,7 @@ There are several issues with this:
     HsCmd or HsPat with extra constructors instead?
 
   * We cannot handle corner cases. For instance, the following function
-    declaration LHS is not a valid expression (see Trac #1087):
+    declaration LHS is not a valid expression (see #1087):
 
       !a + !b = ...
 
index 3a0b1f7..d9a1f8a 100644 (file)
@@ -344,7 +344,7 @@ to
   case x of
     3.8#::Float# -> this
     _            -> that
-See Trac #9238.  Reason: comparing floating-point values for equality
+See #9238.  Reason: comparing floating-point values for equality
 delicate, and we don't want to implement that delicacy in the code for
 case expressions.  So we make it an invariant of Core that a case
 expression never scrutinises a Float# or Double#.
@@ -1070,7 +1070,7 @@ is:
      case e of <transformed alts>
   by PrelRules.caseRules; see Note [caseRules for dataToTag]
 
-See Trac #15696 for a long saga.
+See #15696 for a long saga.
 
 
 ************************************************************************
@@ -1103,7 +1103,7 @@ Things to note
   why not instead say this?
       case x of { DEFAULT -> blah)
 
-  Reason (see Trac #5129): if we saw
+  Reason (see #5129): if we saw
     catch# (\s -> case x of { DEFAULT -> raiseIO# exn s }) handler
 
   then we'd drop the 'case x' because the body of the case is bottom
@@ -1511,7 +1511,7 @@ match_WordToNatural _ _ _ _ = Nothing
 For most types the bitInteger operation can be implemented in terms of shifts.
 The integer-gmp package, however, can do substantially better than this if
 allowed to provide its own implementation. However, in so doing it previously lost
-constant-folding (see Trac #8832). The bitInteger rule above provides constant folding
+constant-folding (see #8832). The bitInteger rule above provides constant folding
 specifically for this function.
 
 There is, however, a bit of trickiness here when it comes to ranges. While the
@@ -1531,7 +1531,7 @@ match_bitInteger dflags id_unf fn [arg]
     -- Make sure x is small enough to yield a decently small iteger
     -- Attempting to construct the Integer for
     --    (bitInteger 9223372036854775807#)
-    -- would be a bad idea (Trac #14959)
+    -- would be a bad idea (#14959)
   , let x_int = fromIntegral x :: Int
   = case splitFunTy_maybe (idType fn) of
     Just (_, integerTy)
@@ -1617,7 +1617,7 @@ match_Integer_shift_op binop _ id_unf _ [xl,yl]
   , y >= 0
   , y <= 4   -- Restrict constant-folding of shifts on Integers, somewhat
              -- arbitrary.  We can get huge shifts in inaccessible code
-             -- (Trac #15673)
+             -- (#15673)
   = Just (Lit (mkLitInteger (x `binop` fromIntegral y) i))
 match_Integer_shift_op _ _ _ _ _ = Nothing
 
@@ -2114,7 +2114,7 @@ we generate
     True  -> e2
 and it is nice to then get rid of the tagToEnum.
 
-Beware (Trac #14768): avoid the temptation to map constructor 0 to
+Beware (#14768): avoid the temptation to map constructor 0 to
 DEFAULT, in the hope of getting this
   case (x ># y) of
     DEFAULT -> e1
@@ -2168,5 +2168,5 @@ out-of-range alterantive is dead code -- we know the range of tags for x.
 Hence caseRules returns (AltCon -> Maybe AltCon), with Nothing indicating
 an alternative that is unreachable.
 
-You may wonder how this can happen: check out Trac #15436.
+You may wonder how this can happen: check out #15436.
 -}
index fd1bab3..edadf15 100644 (file)
@@ -323,7 +323,7 @@ data dependencies of the state token to enforce write-effect ordering
 
  * NB1: if you inline unsafePerformIO, you may end up with
    side-effecting ops whose 'state' output is discarded.
-   And programmers may do that by hand; see Trac #9390.
+   And programmers may do that by hand; see #9390.
    That is why we (conservatively) do not discard write-effecting
    primops even if both their state and result is discarded.
 
@@ -367,13 +367,13 @@ Duplicate      YES           NO
   Arguably you should be able to discard this, since the
   returned stat token is not used, but that relies on NEVER
   inlining unsafePerformIO, and programmers sometimes write
-  this kind of stuff by hand (Trac #9390).  So we (conservatively)
+  this kind of stuff by hand (#9390).  So we (conservatively)
   never discard a has_side_effects primop.
 
   However, it's fine to discard a can_fail primop.  For example
      case (indexIntArray# a i) of _ -> True
   We can discard indexIntArray#; it has can_fail, but not
-  has_side_effects; see Trac #5658 which was all about this.
+  has_side_effects; see #5658 which was all about this.
   Notice that indexIntArray# is (in a more general handling of
   effects) read effect, but we don't care about that here, and
   treat read effects as *not* has_side_effects.
@@ -424,7 +424,7 @@ Duplicate      YES           NO
   (All these bindings are boxed.)  If we inline p at its two call
   sites, we get a catastrophe: because the read is performed once when
   s' is demanded, and once when 'r' is demanded, which may be much
-  later.  Utterly wrong.  Trac #3207 is real example of this happening.
+  later.  Utterly wrong.  #3207 is real example of this happening.
 
   However, it's fine to duplicate a can_fail primop.  That is really
   the only difference between can_fail and has_side_effects.
index d3fd0b9..3e0d87f 100644 (file)
@@ -132,8 +132,8 @@ primTyCons = unexposedPrimTyCons ++ exposedPrimTyCons
 
 -- | Primitive 'TyCon's that are defined in "GHC.Prim" but not exposed.
 -- It's important to keep these separate as we don't want users to be able to
--- write them (see Trac #15209) or see them in GHCi's @:browse@ output
--- (see Trac #12023).
+-- write them (see #15209) or see them in GHCi's @:browse@ output
+-- (see #12023).
 unexposedPrimTyCons :: [TyCon]
 unexposedPrimTyCons
   = [ eqPrimTyCon
index 2740ef7..94de07f 100644 (file)
@@ -2584,7 +2584,7 @@ primop  AtomicallyOp "atomically#" GenPrimOp
 --     (# s2, a #) -> e
 -- with:
 --   retry# s1
--- where 'e' would be unreachable anyway.  See Trac #8091.
+-- where 'e' would be unreachable anyway.  See #8091.
 primop  RetryOp "retry#" GenPrimOp
    State# RealWorld -> (# State# RealWorld, a #)
    with
@@ -3079,7 +3079,7 @@ primop  ReallyUnsafePtrEqualityOp "reallyUnsafePtrEquality#" GenPrimOp
 -- conservative, but it prevented reallyUnsafePtrEquality# from floating out of
 -- places where its arguments were known to be forced. Unfortunately, GHC could
 -- sometimes lose track of whether those arguments were forced, leading to let/app
--- invariant failures (see Trac 13027 and the discussion in Trac 11444). Now that
+-- invariant failures (see #13027 and the discussion in #11444). Now that
 -- ok_for_speculation skips over lifted arguments, we need to explicitly prevent
 -- reallyUnsafePtrEquality# from floating out. Imagine if we had
 --
index 3650fec..22f2cf3 100644 (file)
@@ -307,7 +307,7 @@ rnValBindsRHS ctxt (ValBinds _ mbinds sigs)
                 -- Note [Pattern synonym builders don't yield dependencies]
                 -- But psb_fvs /does/ include those builder fvs.  So we
                 -- add them back in here to avoid bogus warnings about
-                -- unused variables (Trac #12548)
+                -- unused variables (#12548)
 
              valbind'_dus = anal_dus `plusDU` usesOnly sig_fvs
                                      `plusDU` usesOnly patsyn_fvs
@@ -536,7 +536,7 @@ because they don't do anything!  But we have three exceptions:
 * A strict pattern binding; that is, one with an outermost bang
      !Just _ = e
   This can fail, so unlike the lazy variant, it is not a no-op.
-  Moreover, Trac #13646 argues that even for single constructor
+  Moreover, #13646 argues that even for single constructor
   types, you might want to write the constructor.  See also #9127.
 
 * A splice pattern
@@ -805,7 +805,7 @@ So:
    (which is then used for dependency analysis)
  * But we /do/ include them in the psb_fvs for the PatSynBind
  * In rnValBinds we record these builder uses, to avoid bogus
-   unused-variable warnings (Trac #12548)
+   unused-variable warnings (#12548)
 -}
 
 {- *********************************************************************
index 87f8be7..638f7df 100644 (file)
@@ -220,7 +220,7 @@ Looking up a name in the RnEnv.
 
 Note [Type and class operator definitions]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-We want to reject all of these unless we have -XTypeOperators (Trac #3265)
+We want to reject all of these unless we have -XTypeOperators (#3265)
    data a :*: b  = ...
    class a :*: b where ...
    data (:*:) a b  = ....
@@ -518,7 +518,7 @@ Note [Fall back on lookupGlobalOccRn in lookupRecFieldOcc]
 Whenever we fail to find the field or it is not in scope, mb_field
 will be False, and we fall back on looking it up normally using
 lookupGlobalOccRn.  We don't report an error immediately because the
-actual problem might be located elsewhere.  For example (Trac #9975):
+actual problem might be located elsewhere.  For example (#9975):
 
    data Test = Test { x :: Int }
    pattern Test wat = Test { x = wat }
@@ -531,7 +531,7 @@ the environment first, we will try and fail to find `x` amongst the
 (nonexistent) fields of the pattern synonym.
 
 Alternatively, the scope check can fail due to Template Haskell.
-Consider (Trac #12130):
+Consider (#12130):
 
    module Foo where
      import M
@@ -844,7 +844,7 @@ This is guaranteed by extendGlobalRdrEnvRn (the dups check in add_gre).
 
 So how can we get multiple gres in lookupExactOcc_maybe?  Because in
 TH we might use the same TH NameU in two different name spaces.
-eg (Trac #7241):
+eg (#7241):
    $(newName "Foo" >>= \o -> return [DataD [] o [] [RecC o []] [''Show]])
 Here we generate a type constructor and data constructor with the same
 unique, but different name spaces.
@@ -972,7 +972,7 @@ badVarInType rdr_name
 
 {- Note [Promoted variables in types]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider this (Trac #12686):
+Consider this (#12686):
    x = True
    data Bad = Bad 'x
 
@@ -1054,7 +1054,7 @@ lookupInfoOccRn :: RdrName -> RnM [Name]
 -- lookupInfoOccRn is intended for use in GHCi's ":info" command
 -- It finds all the GREs that RdrName could mean, not complaining
 -- about ambiguity, but rather returning them all
--- C.f. Trac #9881
+-- C.f. #9881
 lookupInfoOccRn rdr_name =
   lookupExactOrOrig rdr_name (:[]) $
     do { rdr_env <- getGlobalRdrEnv
@@ -1188,7 +1188,7 @@ lookupGreAvailRn rdr_name
 Note [Handling of deprecations]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 * We report deprecations at each *occurrence* of the deprecated thing
-  (see Trac #5867)
+  (see #5867)
 
 * We do not report deprecations for locally-defined names. For a
   start, we may be exporting a deprecated thing. Also we may use a
@@ -1203,7 +1203,7 @@ Note [Handling of deprecations]
 -}
 
 addUsedDataCons :: GlobalRdrEnv -> TyCon -> RnM ()
--- Remember use of in-scope data constructors (Trac #7969)
+-- Remember use of in-scope data constructors (#7969)
 addUsedDataCons rdr_env tycon
   = addUsedGREs [ gre
                 | dc <- tyConDataCons tycon
@@ -1660,6 +1660,6 @@ badOrigBinding name
     --
     --   $(pure [ValD (VarP 'succ) (NormalB (ConE 'True)) []])
     --
-    -- (See Trac #13968.)
+    -- (See #13968.)
   where
     occ = rdrNameOcc $ filterCTuple name
index bed53ec..b74b557 100644 (file)
@@ -826,7 +826,7 @@ rnStmt ctxt rnBody (L loc (LastStmt _ body noret _)) thing_inside
                             -- The 'return' in a LastStmt is used only
                             -- for MonadComp; and we don't want to report
                             -- "non in scope: return" in other cases
-                            -- Trac #15607
+                            -- #15607
 
         ; (thing,  fvs3) <- thing_inside []
         ; return (([(L loc (LastStmt noExt body' noret ret_op), fv_expr)]
@@ -1305,7 +1305,7 @@ Note [Segmenting mdo]
 ~~~~~~~~~~~~~~~~~~~~~
 NB. June 7 2012: We only glom segments that appear in an explicit mdo;
 and leave those found in "do rec"'s intact.  See
-http://ghc.haskell.org/trac/ghc/ticket/4148 for the discussion
+https://gitlab.haskell.org/ghc/ghc/issues/4148 for the discussion
 leading to this design choice.  Hence the test in segmentRecStmts.
 
 Note [Glomming segments]
index 19d8bb4..1fa81c8 100644 (file)
@@ -124,7 +124,7 @@ lookupFixityRn_help' name occ
   = return (False, Fixity NoSourceText minPrecedence InfixL)
     -- Minimise errors from ubound names; eg
     --    a>0 `foo` b>0
-    -- where 'foo' is not in scope, should not give an error (Trac #7937)
+    -- where 'foo' is not in scope, should not give an error (#7937)
 
   | otherwise
   = do { local_fix_env <- getFixityEnv
@@ -178,7 +178,7 @@ lookupTyFixityRn = lookupFixityRn . unLoc
 -- | Look up the fixity of a (possibly ambiguous) occurrence of a record field
 -- selector.  We use 'lookupFixityRn'' so that we can specifiy the 'OccName' as
 -- the field label, which might be different to the 'OccName' of the selector
--- 'Name' if @DuplicateRecordFields@ is in use (Trac #1173). If there are
+-- 'Name' if @DuplicateRecordFields@ is in use (#1173). If there are
 -- multiple possible selectors with different fixities, generate an error.
 lookupFieldFixityRn :: AmbiguousFieldOcc GhcRn -> RnM Fixity
 lookupFieldFixityRn (Unambiguous n lrdr)
index 08f1007..ba0b5f3 100644 (file)
@@ -239,7 +239,7 @@ convert it back to a list. One nice side effect of this approach is that
 if there's a lot of overlap in the imp_finsts of imports, the
 Set doesn't really need to grow and we don't need to allocate.
 
-Running generateModules from Trac #14693 with DEPTH=16, WIDTH=30 finishes in
+Running generateModules from #14693 with DEPTH=16, WIDTH=30 finishes in
 23s before, and 11s after.
 -}
 
@@ -280,7 +280,7 @@ rnImportDecl this_mod
     let imp_mod_name = unLoc loc_imp_mod_name
         doc = ppr imp_mod_name <+> text "is directly imported"
 
-    -- Check for self-import, which confuses the typechecker (Trac #9032)
+    -- Check for self-import, which confuses the typechecker (#9032)
     -- ghc --make rejects self-import cycles already, but batch-mode may not
     -- at least not until TcIface.tcHiBootIface, which is too late to avoid
     -- typechecker crashes.  (Indirect self imports are not caught until
@@ -296,7 +296,7 @@ rnImportDecl this_mod
           (case mb_pkg of  -- If we have import "<pkg>" M, then we should
                            -- check that "<pkg>" is "this" (which is magic)
                            -- or the name of this_mod's package.  Yurgh!
-                           -- c.f. GHC.findModule, and Trac #9997
+                           -- c.f. GHC.findModule, and #9997
              Nothing         -> True
              Just (StringLiteral _ pkg_fs) -> pkg_fs == fsLit "this" ||
                             fsToUnitId pkg_fs == moduleUnitId this_mod))
@@ -738,9 +738,9 @@ getLocalNonValBinders fixity_env
            -- such as in the following examples:
            --
            -- (1) The class is headed by a bang pattern, such as in
-           --     `instance !Show Int` (Trac #3811c)
+           --     `instance !Show Int` (#3811c)
            -- (2) The class is headed by a type variable, such as in
-           --     `instance c` (Trac #16385)
+           --     `instance c` (#16385)
            --
            -- If looking up the class name fails, then mb_cls_nm will
            -- be Nothing.
@@ -905,7 +905,7 @@ filterImports iface decl_spec (Just (want_hiding, L l import_items))
         -- 'combine' is only called for associated data types which appear
         -- twice in the all_avails. In the example, we combine
         --    T(T,T1,T2,T3) and C(C,T)  to give   (T, T(T,T1,T2,T3), Just C)
-        -- NB: the AvailTC can have fields as well as data constructors (Trac #12127)
+        -- NB: the AvailTC can have fields as well as data constructors (#12127)
         combine (name1, a1@(AvailTC p1 _ _), mp1)
                 (name2, a2@(AvailTC p2 _ _), mp2)
           = ASSERT2( name1 == name2 && isNothing mp1 && isNothing mp2
@@ -1030,7 +1030,7 @@ filterImports iface decl_spec (Just (want_hiding, L l import_items))
                                 -- We are trying to import T( a,b,c,d ), and failed
                                 -- to find 'b' and 'd'.  So we make up an import item
                                 -- to report as failing, namely T( b, d ).
-                                -- c.f. Trac #15412
+                                -- c.f. #15412
 
              Succeeded (childnames, childflds) ->
                case mb_parent of
@@ -1358,7 +1358,7 @@ findImportUsage imports used_gres
         used_names   = mkNameSet (map      gre_name        used_gres)
         used_parents = mkNameSet (mapMaybe greParent_maybe used_gres)
 
-        unused_imps   -- Not trivial; see eg Trac #7454
+        unused_imps   -- Not trivial; see eg #7454
           = case imps of
               Just (False, L _ imp_ies) ->
                                  foldr (add_unused . unLoc) emptyNameSet imp_ies
@@ -1403,7 +1403,7 @@ declaration is actually used in the module.
 
 The SrcLoc is the location of the END of a particular 'import'
 declaration.  Why *END*?  Because we don't want to get confused
-by the implicit Prelude import. Consider (Trac #7476) the module
+by the implicit Prelude import. Consider (#7476) the module
     import Foo( foo )
     main = print foo
 There is an implicit 'import Prelude(print)', and it gets a SrcSpan
@@ -1493,7 +1493,7 @@ Note [Do not warn about Prelude hiding]
 We do not warn about
    import Prelude hiding( x, y )
 because even if nothing else from Prelude is used, it may be essential to hide
-x,y to avoid name-shadowing warnings.  Example (Trac #9061)
+x,y to avoid name-shadowing warnings.  Example (#9061)
    import Prelude hiding( log )
    f x = log where log = ()
 
index 3d5f3b9..ca8c665 100644 (file)
@@ -160,7 +160,7 @@ Consider
 
 Arguably we should report T2 as unused, even though it appears in a
 pattern, because it never occurs in a constructed position.  See
-Trac #7336.
+#7336.
 However, implementing this in the face of pattern synonyms would be
 less straightforward, since given two pattern synonyms
 
@@ -258,7 +258,7 @@ Consider
 Here the pattern binds 'r', and then uses it *only* in the view pattern.
 We want to "see" this use, and in let-bindings we collect all uses and
 report unused variables at the binding level. So we must use bindLocalNames
-here, *not* bindLocalNameFV.  Trac #3943.
+here, *not* bindLocalNameFV.  #3943.
 
 
 Note [Don't report shadowing for pattern synonyms]
@@ -853,7 +853,7 @@ inside IntegralLit and FractionalLit. These types cannot represent negative
 zero value. So we had to add explicit field 'neg' which would hold information
 about literal sign. Here in rnOverLit we use it to detect negative zeroes and
 in this case return not only literal itself but also negateName so that users
-can apply it explicitly. In this case it stays negative zero.  Trac #13211
+can apply it explicitly. In this case it stays negative zero.  #13211
 -}
 
 rnOverLit :: HsOverLit t ->
index 19f0d31..5181b7f 100644 (file)
@@ -127,7 +127,7 @@ rnSrcDecls group@(HsGroup { hs_valds   = val_decls,
 
    -- (D1) Bring pattern synonyms into scope.
    --      Need to do this before (D2) because rnTopBindsLHS
-   --      looks up those pattern synonyms (Trac #9889)
+   --      looks up those pattern synonyms (#9889)
 
    extendPatSynEnv val_decls local_fix_env $ \pat_syn_bndrs -> do {
 
@@ -660,7 +660,7 @@ rnClsInstDecl (ClsInstDecl { cid_poly_ty = inst_ty, cid_binds = mbinds
                -- we report an error and continue for as long as we can.
                -- Importantly, this error should be thrown before we reach the
                -- typechecker, lest we encounter different errors that are
-               -- hopelessly confusing (such as the one in Trac #16114).
+               -- hopelessly confusing (such as the one in #16114).
                addErrAt (getLoc (hsSigType inst_ty)) $
                  hang (text "Illegal class instance:" <+> quotes (ppr inst_ty))
                     2 (vcat [ text "Class instances must be of the form"
@@ -955,7 +955,7 @@ bound on the LHS.  For example, this is not ok
       type F a x :: *
    instance C (p,q) r where
       type F (p,q) x = (x, r)   -- BAD: mentions 'r'
-c.f. Trac #5515
+c.f. #5515
 
 Kind variables, on the other hand, are allowed to be implicitly or explicitly
 bound. As examples, this (#9574) is acceptable:
@@ -980,7 +980,7 @@ So for parity with type synonyms, we also allow:
 
 All this applies only for *instance* declarations.  In *class*
 declarations there is no RHS to worry about, and the class variables
-can all be in scope (Trac #5862):
+can all be in scope (#5862):
     class Category (x :: k -> k -> *) where
       type Ob x :: k -> Constraint
       id :: Ob x a => x a a
@@ -997,7 +997,7 @@ by a forall. For instance, the following is acceptable:
      type forall b. T (Maybe a) b = Either a b
 
 Even though `a` is not bound by the forall, this is still accepted because `a`
-was previously bound by the `instance C (Maybe a)` part. (see Trac #16116).
+was previously bound by the `instance C (Maybe a)` part. (see #16116).
 
 In each case, the function which detects improperly bound variables on the RHS
 is TcValidity.checkValidFamPats.
@@ -1225,7 +1225,7 @@ reasons:
   This has a kind error, but the error message is better if you
   check T first, (fixing its kind) and *then* S.  If you do kind
   inference together, you might get an error reported in S, which
-  is jolly confusing.  See Trac #4875
+  is jolly confusing.  See #4875
 
 
 * Increase kind polymorphism.  See TcTyClsDecls
@@ -1233,7 +1233,7 @@ reasons:
 
 Why do the instance declarations participate?  At least two reasons
 
-* Consider (Trac #11348)
+* Consider (#11348)
 
      type family F a
      type instance F Int = Bool
@@ -1246,7 +1246,7 @@ Why do the instance declarations participate?  At least two reasons
   know that unless we've looked at the type instance declaration for F
   before kind-checking Foo.
 
-* Another example is this (Trac #3990).
+* Another example is this (#3990).
 
      data family Complex a
      data instance Complex Double = CD {-# UNPACK #-} !Double
@@ -2064,7 +2064,7 @@ rnInjectivityAnn _ _ (dL->L srcSpan (InjectivityAnn injFrom injTo)) =
 {-
 Note [Stupid theta]
 ~~~~~~~~~~~~~~~~~~~
-Trac #3850 complains about a regression wrt 6.10 for
+#3850 complains about a regression wrt 6.10 for
      data Show a => T a
 There is no reason not to allow the stupid theta if there are no data
 constructors.  It's still stupid, but does no harm, and I don't want
@@ -2142,7 +2142,7 @@ rnConDecl decl@(ConDeclGADT { con_names   = names
           -- order of their appearance in the constructor type.
           -- That order governs the order the implicitly-quantified type
           -- variable, and hence the order needed for visible type application
-          -- See Trac #14808.
+          -- See #14808.
               free_tkvs = extractHsTvBndrs explicit_tkvs $
                           extractHsTysRdrTyVarsDups (theta ++ arg_tys ++ [res_ty])
 
@@ -2325,7 +2325,7 @@ add gp loc (SpliceD _ splice@(SpliceDecl _ _ flag)) ds
                      -- The compiler should suggest the above, and not using
                      -- TemplateHaskell since the former suggestion is more
                      -- relevant to the larger base of users.
-                     -- See Trac #12146 for discussion.
+                     -- See #12146 for discussion.
 
 -- Class declarations: pull out the fixity signatures to the top
 add gp@(HsGroup {hs_tyclds = ts, hs_fixds = fs}) l (TyClD _ d) ds
index a0c926d..1d5c68f 100644 (file)
@@ -447,16 +447,16 @@ rnSpliceExpr splice
 {- Note [Running splices in the Renamer]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Splices used to be run in the typechecker, which led to (Trac #4364). Since the
+Splices used to be run in the typechecker, which led to (#4364). Since the
 renamer must decide which expressions depend on which others, and it cannot
 reliably do this for arbitrary splices, we used to conservatively say that
 splices depend on all other expressions in scope. Unfortunately, this led to
-the problem of cyclic type declarations seen in (Trac #4364). Instead, by
+the problem of cyclic type declarations seen in (#4364). Instead, by
 running splices in the renamer, we side-step the problem of determining
 dependencies: by the time the dependency analysis happens, any splices have
 already been run, and expression dependencies can be determined as usual.
 
-However, see (Trac #9813), for an example where we would like to run splices
+However, see (#9813), for an example where we would like to run splices
 *after* performing dependency analysis (that is, after renaming). It would be
 desirable to typecheck "non-splicy" expressions (those expressions that do not
 contain splices directly or via dependence on an expression that does) before
@@ -477,7 +477,7 @@ we wish to first determine dependencies and typecheck certain expressions,
 making them available to reify, but cannot accurately determine dependencies
 without running splices in the renamer!
 
-Indeed, the conclusion of (Trac #9813) was that it is not worth the complexity
+Indeed, the conclusion of (#9813) was that it is not worth the complexity
 to try and
  a) implement and maintain the code for renaming/typechecking non-splicy
     expressions before splicy expressions,
@@ -490,7 +490,7 @@ to try and
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 When splices run in the renamer, 'reify' does not have access to the local
-type environment (Trac #11832, [1]).
+type environment (#11832, [1]).
 
 For instance, in
 
@@ -856,7 +856,7 @@ ensures that 'f' stays as a top level binding.
 
 This must be done by the renamer, not the type checker (as of old),
 because the type checker doesn't typecheck the body of untyped
-brackets (Trac #8540).
+brackets (#8540).
 
 A thing can have a bind_lvl of outerLevel, but have an internal name:
    foo = [d| op = 3
index 53bcade..755ed20 100644 (file)
@@ -352,7 +352,7 @@ Variables in type signatures are implicitly quantified
 when (1) they are in a type signature not beginning
 with "forall" or (2) in any qualified type T => R.
 We are phasing out (2) since it leads to inconsistencies
-(Trac #4426):
+(#4426):
 
 data A = A (a -> a)           is an error
 data A = A (Eq a => a -> a)   binds "a"
@@ -1335,7 +1335,7 @@ checkSectionPrec direction section op arg
 
 -- | Look up the fixity for an operator name.  Be careful to use
 -- 'lookupFieldFixityRn' for (possibly ambiguous) record fields
--- (see Trac #13132).
+-- (see #13132).
 lookupFixityOp :: OpName -> RnM Fixity
 lookupFixityOp (NormalOp n)  = lookupFixityRn n
 lookupFixityOp NegateOp      = lookupFixityRn negateName
index 9de4aac..a4715a2 100644 (file)
@@ -149,7 +149,7 @@ checkShadowedOccs (global_env,local_env) get_loc_occ ns
   where
     check_shadow n
         | startsWithUnderscore occ = return ()  -- Do not report shadowing for "_x"
-                                                -- See Trac #3262
+                                                -- See #3262
         | Just n <- mb_local = complain [text "bound at" <+> ppr (nameSrcLoc n)]
         | otherwise = do { gres' <- filterM is_shadowed_gre gres
                          ; complain (map pprNameProvenance gres') }
@@ -167,7 +167,7 @@ checkShadowedOccs (global_env,local_env) get_loc_occ ns
 
     is_shadowed_gre :: GlobalRdrElt -> RnM Bool
         -- Returns False for record selectors that are shadowed, when
-        -- punning or wild-cards are on (cf Trac #2723)
+        -- punning or wild-cards are on (cf #2723)
     is_shadowed_gre gre | isRecFldGRE gre
         = do { dflags <- getDynFlags
              ; return $ not (xopt LangExt.RecordPuns dflags
@@ -385,7 +385,7 @@ addNameClashErrRn rdr_name gres
     --   It could refer to either ‘T15487a.null’,
     --                            imported from ‘Prelude’ at T15487.hs:1:8-13
     --                     or ...
-    -- See Trac #15487
+    -- See #15487
     pp_gre_name gre@(GRE { gre_name = name, gre_par = parent
                          , gre_lcl = lcl, gre_imp = iss })
       | FldParent { par_lbl = Just lbl } <- parent
index 96fbd07..0758ce9 100644 (file)
@@ -84,7 +84,7 @@ Let-bindings have two cases, implemented by addBinding.
 
     - First, the original RHS might have been (g z) which has CSE'd
       with an enclosing (let y = g z in ...).  This is super-important.
-      See Trac #5996:
+      See #5996:
          x1 = C a b
          x2 = C x1 b
          y1 = C a b
@@ -104,7 +104,7 @@ Let-bindings have two cases, implemented by addBinding.
 
   Note that we use EXTEND even for a trivial expression, provided it
   is not a variable or literal. In particular this /includes/ type
-  applications. This can be important (Trac #13156); e.g.
+  applications. This can be important (#13156); e.g.
      case f @ Int of { r1 ->
      case f @ Int of { r2 -> ...
   Here we want to common-up the two uses of (f @ Int) so we can
@@ -419,7 +419,7 @@ addBinding env in_id out_id rhs'
        -- Putting the Id into the cs_map makes it possible that
        -- it'll become shared more than it is now, which would
        -- invalidate (the usage part of) its demand info.
-       --    This caused Trac #100218.
+       --    This caused #100218.
        -- Easiest thing is to zap the usage info; subsequently
        -- performing late demand-analysis will restore it.  Don't zap
        -- the strictness info; it's not necessary to do so, and losing
@@ -475,11 +475,11 @@ The net effect is that for the y-binding we want to
   - Use SUBSTITUTE, by extending the substitution with  y :-> x
   - but leave the original binding for y undisturbed
 
-This is done by cse_bind.  I got it wrong the first time (Trac #13367).
+This is done by cse_bind.  I got it wrong the first time (#13367).
 
 Note [Delay inlining after CSE]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Suppose (Trac #15445) we have
+Suppose (#15445) we have
    f,g :: Num a => a -> a
    f x = ...f (x-1).....
    g y = ...g (y-1) ....
index ba1aa24..bd5b3a3 100644 (file)
@@ -418,7 +418,7 @@ like normal functions. This is ok.
 The analysis *could* make use of the fact that join points are always evaluated
 in the same context as the join-binding they are defined in and are always
 one-shot, and handle join points separately, as suggested in
-https://ghc.haskell.org/trac/ghc/ticket/13479#comment:10.
+https://gitlab.haskell.org/ghc/ghc/issues/13479#note_134870.
 This *might* be more efficient (for example, join points would not have to be
 considered interesting variables), but it would also add redundant code. So for
 now we do not do that.
index 0c5d8d9..4cdb231 100644 (file)
@@ -558,7 +558,7 @@ data CoreReader = CoreReader {
 
 -- Note: CoreWriter used to be defined with data, rather than newtype.  If it
 -- is defined that way again, the cw_simpl_count field, at least, must be
--- strict to avoid a space leak (Trac #7702).
+-- strict to avoid a space leak (#7702).
 newtype CoreWriter = CoreWriter {
         cw_simpl_count :: SimplCount
 }
@@ -589,7 +589,7 @@ instance Monad CoreM where
             let w = w1 `plusWriter` w2
             return $ seq w (y, s'', w)
             -- forcing w before building the tuple avoids a space leak
-            -- (Trac #7702)
+            -- (#7702)
 
 instance Applicative CoreM where
     pure x = CoreM $ \s -> nop s x
index 3e7d503..f5a4138 100644 (file)
@@ -245,7 +245,7 @@ exitifyRec in_scope pairs
                                | otherwise           = (fvs',               acc)
 
         -- We are going to abstract over these variables, so we must
-        -- zap any IdInfo they have; see Trac #15005
+        -- zap any IdInfo they have; see #15005
         -- cf. SetLevels.abstractVars
         zap v | isId v = setIdInfo v vanillaIdInfo
               | otherwise = v
index 07f0549..216e848 100644 (file)
@@ -210,7 +210,7 @@ only way that can happen is if the binding wrapped the literal
 /in the original input program/.  e.g.
    case x of { DEFAULT -> 1# }
 But, while this may be unusual it is not actually wrong, and it did
-once happen (Trac #15696).
+once happen (#15696).
 
 Note [Do not destroy the let/app invariant]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -307,7 +307,7 @@ be dropped right away.
 
 fiExpr dflags to_drop lam@(_, AnnLam _ _)
   | noFloatIntoLam bndrs       -- Dump it all here
-     -- NB: Must line up with noFloatIntoRhs (AnnLam...); see Trac #7088
+     -- NB: Must line up with noFloatIntoRhs (AnnLam...); see #7088
   = wrapFloats to_drop (mkLams bndrs (fiExpr dflags [] body))
 
   | otherwise           -- Float inside
@@ -391,7 +391,7 @@ fiExpr dflags to_drop (_,AnnLet bind body)
 {- Note [Floating primops]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 We try to float-in a case expression over an unlifted type.  The
-motivating example was Trac #5658: in particular, this change allows
+motivating example was #5658: in particular, this change allows
 array indexing operations, which have a single DEFAULT alternative
 without any binders, to be floated inward.
 
@@ -421,10 +421,10 @@ But there are wrinkles
   Solution: only float cases into the branches of other cases, and
   not into the arguments of an application, or the RHS of a let. This
   is somewhat conservative, but it's simple.  And it still hits the
-  cases like Trac #5658.   This is implemented in sepBindsByJoinPoint;
+  cases like #5658.   This is implemented in sepBindsByJoinPoint;
   if is_case is False we dump all floating cases right here.
 
-* Trac #14511 is another example of why we want to restrict float-in
+* #14511 is another example of why we want to restrict float-in
   of case-expressions.  Consider
      case indexArray# a n of (# r #) -> writeArray# ma i (f r)
   Now, floating that indexing operation into the (f r) thunk will
@@ -613,7 +613,7 @@ would destroy the let/app invariant.
      (a) any non-one-shot value lambdas
   or (b) all type lambdas
   In both cases we'll float straight back out again
-  NB: Must line up with fiExpr (AnnLam...); see Trac #7088
+  NB: Must line up with fiExpr (AnnLam...); see #7088
 
   (a) is important: we /must/ float into a one-shot lambda group
   (which includes join points). This makes a big difference
index 0aa4854..1f1dd5c 100644 (file)
@@ -305,7 +305,7 @@ Nor is it a good idea to dump them in the rhs, but outside the lambda
     f = case x of I# y -> \xy. body
 because now f's arity might get worse, which is Not Good. (And if
 there's an SCC around the RHS it might not get better again.
-See Trac #5342.)
+See #5342.)
 
 So, gruesomely, we split the floats into
  * the outer FloatLets, which can join the Rec, and
index c3414b1..ecad4a5 100644 (file)
@@ -83,7 +83,7 @@ occurAnalysePgm this_mod active_unf active_rule imp_rules binds
                                                     initial_uds
           -- It's crucial to re-analyse the glommed-together bindings
           -- so that we establish the right loop breakers. Otherwise
-          -- we can easily create an infinite loop (Trac #9583 is an example)
+          -- we can easily create an infinite loop (#9583 is an example)
 
     initial_uds = addManyOccsSet emptyDetails
                             (rulesFreeVars imp_rules)
@@ -124,7 +124,7 @@ occurAnalyseExpr' enable_binder_swap expr
 
 {- Note [Plugin rules]
 ~~~~~~~~~~~~~~~~~~~~~~
-Conal Elliott (Trac #11651) built a GHC plugin that added some
+Conal Elliott (#11651) built a GHC plugin that added some
 BuiltinRules (for imported Ids) to the mg_rules field of ModGuts, to
 do some domain-specific transformations that could not be expressed
 with an ordinary pattern-matching CoreRule.  But then we can't extract
@@ -1020,7 +1020,7 @@ terminate in a constant number of iterations, rather than O(N)
 iterations.
 
 You might thing that it's very unlikely, but RULES make it much
-more likely.  Here's a real example from Trac #1969:
+more likely.  Here's a real example from #1969:
   Rec { $dm = \d.\x. op d
         {-# RULES forall d. $dm Int d  = $s$dm1
                   forall d. $dm Bool d = $s$dm2 #-}
@@ -1439,7 +1439,7 @@ Note [Loop breakers, node scoring, and stability]
 To choose a loop breaker, we give a NodeScore to each node in the SCC,
 and pick the one with the best score (according to 'betterLB').
 
-We need to be jolly careful (Trac #12425, #12234) about the stability
+We need to be jolly careful (#12425, #12234) about the stability
 of this choice. Suppose we have
 
     let rec { f = ...g...g...
@@ -1610,10 +1610,10 @@ Consider
    join j = Just x
 
 We want to inline x into j right away, so we don't want to give
-the join point a RhsCtxt (Trac #14137).  It's not a huge deal, because
+the join point a RhsCtxt (#14137).  It's not a huge deal, because
 the FloatIn pass knows to float into join point RHSs; and the simplifier
 does not float things out of join point RHSs.  But it's a simple, cheap
-thing to do.  See Trac #14137.
+thing to do.  See #14137.
 
 Note [Cascading inlines]
 ~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1932,7 +1932,7 @@ A': Non-obviously saturated applications: eg    build (f (\x y -> expensive))
     that sense, f is saturated, and we may proceed as described above.
 
     Hence the computation of 'guaranteed_val_args' in occAnalApp, using
-    '(occ_one_shots env)'.  See also Trac #13227, comment:9
+    '(occ_one_shots env)'.  See also #13227, comment:9
 
 B:  Let-bindings:  eg   let f = \c. let ... in \n -> blah
                         in (build f, build f)
@@ -2322,7 +2322,7 @@ we will get
 
 Core Lint never expects to find an *occurrence* of an Id marked
 as Dead, so we must zap the OccInfo on cb before making the
-binding x = cb.  See Trac #5028.
+binding x = cb.  See #5028.
 
 NB: the OccInfo on /occurrences/ really doesn't matter much; the simplifier
 doesn't use it. So this is only to satisfy the perhpas-over-picky Lint.
@@ -2409,7 +2409,7 @@ mkAltEnv env@(OccEnv { occ_gbl_scrut = pe }) scrut case_bndr
                        , Just (localise v, rhs) )
       -- ToDO: this isGlobalId stuff is a TEMPORARY FIX
       --       to avoid the binder-swap for GlobalIds
-      --       See Trac #16346
+      --       See #16346
 
     case_bndr' = Var (zapIdOccInfo case_bndr)
                    -- See Note [Zap case binders in proxy bindings]
@@ -2556,7 +2556,7 @@ It's obviously wrong to mark CoVars as dead if they are used.
 Currently we don't traverse types to gather usase info for CoVars,
 so we had better treat them as having noOccInfo.
 
-This showed up in Trac #15696 we had something like
+This showed up in #15696 we had something like
   case eq_sel d of co -> ...(typeError @(...co...) "urk")...
 
 Then 'd' was substitued by a dictionary, so the expression
@@ -2828,7 +2828,7 @@ unfolding captured by the INLINE pragma has arity 1.  If we try to
 convert g to be a join point, its unfolding will still have arity 1
 (since it is stable, and we don't meddle with stable unfoldings), and
 Lint will complain (see Note [Invariants on join points], (2a), in
-CoreSyn.  Trac #13413.
+CoreSyn.  #13413.
 
 Moreover, since g is going to be inlined anyway, there is no benefit
 from making it a join point.
index 2f993b7..fef15a4 100644 (file)
@@ -548,7 +548,7 @@ must be careful to test the *result* scrutinee ('x' in this case), not
 the *input* one 'y'.  The latter *is* in HNF here (because y is
 evaluated), but the former is not -- and indeed we can't float the
 inner case out, at least not unless x is also evaluated at its binding
-site.  See Trac #5453.
+site.  See #5453.
 
 That's why we apply exprIsHNF to scrut' and not to scrut.
 
@@ -755,7 +755,7 @@ I think this is obselete; the flag seems always on.]
 Note [Floating join point bindings]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Mostly we only float a join point if it can /stay/ a join point.  But
-there is one exception: if it can go to the top level (Trac #13286).
+there is one exception: if it can go to the top level (#13286).
 Consider
   f x = joinrec j y n = <...j y' n'...>
         in jump j x 0
@@ -808,7 +808,7 @@ and replace the original (f x) with
    case (case y of I# r -> r) of r -> blah
 
 Being able to float unboxed expressions is sometimes important; see
-Trac #12603.  I'm not sure how /often/ it is important, but it's
+#12603.  I'm not sure how /often/ it is important, but it's
 not hard to achieve.
 
 We only do it for a fixed collection of types for which we have a
@@ -912,7 +912,7 @@ Id, *immediately*, for three reasons:
     errors, e.g. via a case with empty alternatives:  (case x of {})
     Lint complains unless the scrutinee of such a case is clearly bottom.
 
-    This was reported in Trac #11290.   But since the whole bottoming-float
+    This was reported in #11290.   But since the whole bottoming-float
     thing is based on the cheap-and-cheerful exprIsBottom, I'm not sure
     that it'll nail all such cases.
 
@@ -1267,7 +1267,7 @@ Conclusion: use lvlMFE if there are
   * any value lambdas in the original function, and
   * this is not a bottoming function (the is_bot argument)
 Use lvlExpr otherwise.  A little subtle, and I got it wrong at least twice
-(e.g. Trac #13369).
+(e.g. #13369).
 -}
 
 {-
@@ -1398,7 +1398,7 @@ That's why we have this as_far_as_poss stuff.  Usually as_far_as_poss
 is just tOP_LEVEL; but occasionally a coercion variable (which is an
 Id) mentioned in type prevents this.
 
-Example Trac #14270 comment:15.
+Example #14270 comment:15.
 -}
 
 
index 168ece9..7f2a0ea 100644 (file)
@@ -339,7 +339,7 @@ getCoreToDo dflags
         -- really really one-shot thunks. Only needed if the demand analyser
         -- has run at all. See Note [Final Demand Analyser run] in DmdAnal
         -- It is EXTREMELY IMPORTANT to run this pass, otherwise execution
-        -- can become /exponentially/ more expensive. See Trac #11731, #12996.
+        -- can become /exponentially/ more expensive. See #11731, #12996.
         runWhen (strictness || late_dmd_anal) CoreDoStrictness,
 
         maybe_rule_check (Phase 0)
index 81654e9..17a3232 100644 (file)
@@ -97,7 +97,7 @@ computeMaxTicks dflags size
         -- MAGIC NUMBER, multiplies the simplTickFactor
         -- We can afford to be generous; this is really
         -- just checking for loops, and shouldn't usually fire
-        -- A figure of 20 was too small: see Trac #5539.
+        -- A figure of 20 was too small: see #5539.
 
 {-# INLINE thenSmpl #-}
 {-# INLINE thenSmpl_ #-}
index 265b0fb..f42a5d9 100644 (file)
@@ -542,7 +542,7 @@ on its first argument -- it must be saturated for these to kick in
 
 Note [Do not expose strictness if sm_inline=False]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Trac #15163 showed a case in which we had
+#15163 showed a case in which we had
 
   {-# INLINE [1] zip #-}
   zip = undefined
@@ -708,7 +708,7 @@ float, exposing the value, if we inline.  That makes it different to
 exprIsHNF.
 
 Before 2009 we said it was interesting if the argument had *any* structure
-at all; i.e. (hasSomeUnfolding v).  But does too much inlining; see Trac #3016.
+at all; i.e. (hasSomeUnfolding v).  But does too much inlining; see #3016.
 
 But we don't regard (f x y) as interesting, unless f is unsaturated.
 If it's saturated and f hasn't inlined, then it's probably not going
@@ -822,12 +822,12 @@ When simplifying a rule LHS, refrain from /any/ inlining or applying
 of other RULES.
 
 Doing anything to the LHS is plain confusing, because it means that what the
-rule matches is not what the user wrote. c.f. Trac #10595, and #10528.
+rule matches is not what the user wrote. c.f. #10595, and #10528.
 Moreover, inlining (or applying rules) on rule LHSs risks introducing
-Ticks into the LHS, which makes matching trickier. Trac #10665, #10745.
+Ticks into the LHS, which makes matching trickier. #10665, #10745.
 
 Doing this to either side confounds tools like HERMIT, which seek to reason
-about and apply the RULES as originally written. See Trac #10829.
+about and apply the RULES as originally written. See #10829.
 
 Note [No eta expansion in stable unfoldings]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -844,7 +844,7 @@ we do not want to eta-expand to
   --    = (/\a \(d:Ord a) (x:a) (eta:State#). bla eta) |> co
 
 because not specialisation of the overloading doesn't work properly
-(see Note [Specialisation shape] in Specialise), Trac #9509.
+(see Note [Specialisation shape] in Specialise), #9509.
 
 So we disable eta-expansion in stable unfoldings.
 
@@ -1109,7 +1109,7 @@ it might make fInt look big, and we'll lose the opportunity to inline f
 at each of fInt's call sites.  The INLINE pragma will only inline when
 the application is saturated for exactly this reason; and we don't
 want PreInlineUnconditionally to second-guess it.  A live example is
-Trac #3736.
+#3736.
     c.f. Note [Stable unfoldings and postInlineUnconditionally]
 
 NB: if the pragma is INLINEABLE, then we don't want to behave in
@@ -1516,7 +1516,7 @@ tryEtaExpandRhs mode bndr rhs
        ; return (count isId join_bndrs, exprIsBottom join_body, rhs) }
          -- Note [Do not eta-expand join points]
          -- But do return the correct arity and bottom-ness, because
-         -- these are used to set the bndr's IdInfo (Trac #15517)
+         -- these are used to set the bndr's IdInfo (#15517)
 
   | otherwise
   = do { (new_arity, is_bot, new_rhs) <- try_expand
@@ -1614,7 +1614,7 @@ Note [Do not eta-expand PAPs]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 We used to have old_arity = manifestArity rhs, which meant that we
 would eta-expand even PAPs.  But this gives no particular advantage,
-and can lead to a massive blow-up in code size, exhibited by Trac #9020.
+and can lead to a massive blow-up in code size, exhibited by #9020.
 Suppose we have a PAP
     foo :: IO ()
     foo = returnIO ()
@@ -1731,7 +1731,7 @@ new binding is abstracted.  Note that
          poly_t = /\ a b -> (e1, e2)
          poly_x = /\ a   -> fst (poly_t a *b*)
 
-  * We must do closeOverKinds.  Example (Trac #10934):
+  * We must do closeOverKinds.  Example (#10934):
        f = /\k (f:k->*) (a:k). let t = AccFailure @ (f a) in ...
     Here we want to float 't', but we must remember to abstract over
     'k' as well, even though it is not explicitly mentioned in the RHS,
index 2156dc5..0130e06 100644 (file)
@@ -746,7 +746,7 @@ arity computation it performs (via CoreArity.findRhsArity) already
 does a simple bottoming-expression analysis.  So all we need to do
 is propagate that info to the binder's IdInfo.
 
-This showed up in Trac #12150; see comment:16.
+This showed up in #12150; see comment:16.
 
 Note [Setting the demand info]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1218,7 +1218,7 @@ rebuild env expr cont
 {- Note [Optimising reflexivity]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 It's important (for compiler performance) to get rid of reflexivity as soon
-as it appears.  See Trac #11735, #14737, and #15019.
+as it appears.  See #11735, #14737, and #15019.
 
 In particular, we want to behave well on
 
@@ -1232,7 +1232,7 @@ In particular, we want to behave well on
    build up NthCo stacks.  Silly to do that if co is reflexive.
 
 However, we don't want to call isReflexiveCo too much, because it uses
-type equality which is expensive on big types (Trac #14737 comment:7).
+type equality which is expensive on big types (#14737 comment:7).
 
 A good compromise (determined experimentally) seems to be to call
 isReflexiveCo
@@ -1240,7 +1240,7 @@ isReflexiveCo
  * at the end
 
 In investigating this I saw missed opportunities for on-the-fly
-coercion shrinkage. See Trac #15090.
+coercion shrinkage. See #15090.
 -}
 
 
@@ -1292,7 +1292,7 @@ simplCast env body co0 cont0
                     -- 'co' with the InExpr 'arg', so we simplify
                     -- to make it all consistent.  It's a bit messy.
                     -- But it isn't a common case.
-                    -- Example of use: Trac #995
+                    -- Example of use: #995
                ; return (ApplyToVal { sc_arg  = mkCast arg' co1
                                     , sc_env  = arg_se'
                                     , sc_dup  = dup'
@@ -1524,7 +1524,7 @@ Simplifying rules and stable-unfoldings happens a bit after
 simplifying the right-hand side, so we remember whether or not it
 is a join point, and what 'cont' is, in a value of type MaybeJoinCont
 
-Trac #13900 wsa caused by forgetting to push 'cont' into the RHS
+#13900 wsa caused by forgetting to push 'cont' into the RHS
 of a SpecConstr-generated RULE for a join point.
 -}
 
@@ -2269,7 +2269,7 @@ where 'r' is used strictly in (..r..), we can safely transform to
 This is a Good Thing, because 'r' might be dead (if the body just
 calls error), or might be used just once (in which case it can be
 inlined); or we might be able to float the let-binding up or down.
-E.g. Trac #15631 has an example.
+E.g. #15631 has an example.
 
 Note that this can change the error behaviour.  For example, we might
 transform
@@ -2280,7 +2280,7 @@ let-bound to (error "good").
 
 Nevertheless, the paper "A semantics for imprecise exceptions" allows
 this transformation. If you want to fix the evaluation order, use
-'pseq'.  See Trac #8900 for an example where the loss of this
+'pseq'.  See #8900 for an example where the loss of this
 transformation bit us in practice.
 
 See also Note [Empty case alternatives] in CoreSyn.
@@ -2298,7 +2298,7 @@ There have been various earlier versions of this patch:
     scrut_is_demanded_var _          = False
 
   This only fired if the scrutinee was a /variable/, which seems
-  an unnecessary restriction. So in Trac #15631 I relaxed it to allow
+  an unnecessary restriction. So in #15631 I relaxed it to allow
   arbitrary scrutinees.  Less code, less to explain -- but the change
   had 0.00% effect on nofib.
 
@@ -2313,7 +2313,7 @@ There have been various earlier versions of this patch:
     case_bndr_evald_next (Case e _ _ _)  = case_bndr_evald_next e
     case_bndr_evald_next _               = False
 
-  This patch was part of fixing Trac #7542. See also
+  This patch was part of fixing #7542. See also
   Note [Eta reduction of an eval'd function] in CoreUtils.)
 
 
@@ -2562,7 +2562,7 @@ We'd like to transform
 so that 'rhs' can take advantage of the form of x'.  Notice that Note
 [Case of cast] (in OccurAnal) may then apply to the result.
 
-We'd also like to eliminate empty types (Trac #13468). So if
+We'd also like to eliminate empty types (#13468). So if
 
     data Void
     type instance F Bool = Void
@@ -2698,7 +2698,7 @@ NB: simplLamBinders preserves this eval info
 
 In addition to handling data constructor fields with !s, addEvals
 also records the fact that the result of seq# is always in WHNF.
-See Note [seq# magic] in PrelRules.  Example (Trac #15226):
+See Note [seq# magic] in PrelRules.  Example (#15226):
 
   case seq# v s of
     (# s', v' #) -> E
@@ -2707,7 +2707,7 @@ we want the compiler to be aware that v' is in WHNF in E.
 
 Open problem: we don't record that v itself is in WHNF (and we can't
 do it here).  The right thing is to do some kind of binder-swap;
-see Trac #15226 for discussion.
+see #15226 for discussion.
 -}
 
 addEvals :: Maybe OutExpr -> DataCon -> [Id] -> [Id]
@@ -2799,7 +2799,7 @@ The let/app invariant requires that y is evaluated in the call to
 reallyUnsafePtrEq#, which it is.  But we still want that to be true if we
 propagate binders to occurrences.
 
-This showed up in Trac #13027.
+This showed up in #13027.
 
 Note [Add unfolding for scrutinee]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -2975,7 +2975,7 @@ When we have
        of alts
 then we can just duplicate those alts because the A and C cases
 will disappear immediately.  This is more direct than creating
-join points and inlining them away.  See Trac #4930.
+join points and inlining them away.  See #4930.
 -}
 
 --------------------
@@ -3208,7 +3208,7 @@ Supposing that body is big, we end up with
 This is just what we want because the rn produces a box that
 the case rn cancels with.
 
-See Trac #4957 a fuller example.
+See #4957 a fuller example.
 
 Note [Case binders and join points]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -3306,7 +3306,7 @@ them.  Thus:
 Now if the thing in the hole is a case expression (which is when
 we'll call mkDupableCont), we'll push the function call into the
 branches, which is what we want.  Now RULES for f may fire, and
-call-pattern specialisation.  Here's an example from Trac #3116
+call-pattern specialisation.  Here's an example from #3116
      go (n+1) (case l of
                  1  -> bs'
                  _  -> Chunk p fpc (o+1) (l-1) bs')
@@ -3489,7 +3489,7 @@ simplStableUnfolding env top_lvl mb_cont id unf rhs_ty
                         -- has got small. This happens, notably in the inlinings
                         -- for dfuns for single-method classes; see
                         -- Note [Single-method classes] in TcInstDcls.
-                        -- A test case is Trac #4138
+                        -- A test case is #4138
                         -- But retain a previous boring_ok of True; e.g. see
                         -- the way it is set in calcUnfoldingGuidanceWithArity
                         in return (mkCoreUnfolding src is_top_lvl expr' guide')
index fbccf80..386515e 100644 (file)
@@ -78,7 +78,7 @@ Consider two unboxed sum terms:
 These two terms are not equal as they unarise to different unboxed
 tuples. However if we run StgCse before Unarise, it'll think the two
 terms (# 1 | #) are equal, and replace one of these with a binder to
-the other. That's bad -- Trac #15300.
+the other. That's bad -- #15300.
 
 Solution: do unarise first.
 
index d46e641..db85b99 100644 (file)
@@ -18,7 +18,7 @@ import qualified StgLiftLams.Transformation as Transformation
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 -- $note
 -- See also the <https://ghc.haskell.org/trac/ghc/wiki/LateLamLift wiki page>
--- and Trac #9476.
+-- and #9476.
 --
 -- The basic idea behind lambda lifting is to turn locally defined functions
 -- into top-level functions. Free variables are then passed as additional
index ad6a075..df6196a 100644 (file)
@@ -440,7 +440,7 @@ isMoreSpecific :: CoreRule -> CoreRule -> Bool
 -- anything else, because we want user-define rules to "win"
 -- In particular, class ops have a built-in rule, but we
 -- any user-specific rules to win
---   eg (Trac #4397)
+--   eg (#4397)
 --      truncate :: (RealFrac a, Integral b) => a -> b
 --      {-# RULES "truncate/Double->Int" truncate = double2Int #-}
 --      double2Int :: Double -> Int
@@ -619,7 +619,7 @@ It can be the case that the binder in a rule is not actually
 bound on the LHS:
 
 * Type variables.  Type synonyms with phantom args can give rise to
-  unbound template type variables.  Consider this (Trac #10689,
+  unbound template type variables.  Consider this (#10689,
   simplCore/should_compile/T10689):
 
     type Foo a b = b
@@ -653,7 +653,7 @@ bound on the LHS:
   fires we can substitute <t> for c.
 
   This actually happened (in a RULE for a local function)
-  in Trac #13410, and also in test T10602.
+  in #13410, and also in test T10602.
 
 
 Note [Cloning the template binders]
@@ -674,11 +674,11 @@ binders if they are already in scope.
 ------ Historical note -------
 At one point I tried simply adding the template binders to the
 in-scope set /without/ cloning them, but that failed in a horribly
-obscure way in Trac #14777.  Problem was that during matching we look
+obscure way in #14777.  Problem was that during matching we look
 up target-term variables in the in-scope set (see Note [Lookup
 in-scope]).  If a target-term variable happens to name-clash with a
 template variable, that lookup will find the template variable, which
-is /utterly/ bogus.  In Trac #14777, this transformed a term variable
+is /utterly/ bogus.  In #14777, this transformed a term variable
 into a type variable, and then crashed when we wanted its idInfo.
 ------ End of historical note -------
 
index b07e480..8ced5a8 100644 (file)
@@ -506,13 +506,13 @@ sc_force to True when calling specLoop. This flag does four things:
   * Ignore specConstrCount, to make arbitrary numbers of specialisations
         (see specialise)
   * Specialise even for arguments that are not scrutinised in the loop
-        (see argToPat; Trac #4448)
+        (see argToPat; #4448)
   * Only specialise on recursive types a finite number of times
-        (see is_too_recursive; Trac #5550; Note [Limit recursive specialisation])
+        (see is_too_recursive; #5550; Note [Limit recursive specialisation])
 
 The flag holds only for specialising a single binding group, and NOT
 for nested bindings.  (So really it should be passed around explicitly
-and not stored in ScEnv.)  Trac #14379 turned out to be caused by
+and not stored in ScEnv.)  #14379 turned out to be caused by
    f SPEC x = let g1 x = ...
               in ...
 We force-specialise f (because of the SPEC), but that generates a specialised
@@ -599,7 +599,7 @@ more than N times (controlled by -fspec-constr-recursive=N) we check
     specialisations.  If sc_count is "no limit" then we arbitrarily
     choose 10 as the limit (ugh).
 
-See Trac #5550.   Also Trac #13623, where this test had become over-aggressive,
+See #5550.   Also #13623, where this test had become over-aggressive,
 and we lost a wonderful specialisation that we really wanted!
 
 Note [NoSpecConstr]
@@ -746,7 +746,7 @@ because the x-binding still exists and we've now duplicated (expensive v).
 
 This seldom happens because let-bound constructor applications are
 ANF-ised, but it can happen as a result of on-the-fly transformations in
-SpecConstr itself.  Here is Trac #7865:
+SpecConstr itself.  Here is #7865:
 
         let {
           a'_shr =
@@ -946,7 +946,7 @@ extendBndr  env bndr  = (env { sc_subst = subst' }, bndr')
 extendValEnv :: ScEnv -> Id -> Maybe Value -> ScEnv
 extendValEnv env _  Nothing   = env
 extendValEnv env id (Just cv)
- | valueIsWorkFree cv      -- Don't duplicate work!!  Trac #7865
+ | valueIsWorkFree cv      -- Don't duplicate work!!  #7865
  = env { sc_vals = extendVarEnv (sc_vals env) id cv }
 extendValEnv env _ _ = env
 
@@ -1048,7 +1048,7 @@ So in extendCaseBndrs we must *also* add the binding
 else we lose a useful specialisation for f.  This is necessary even
 though the simplifier has systematically replaced uses of 'x' with 'y'
 and 'b' with 'c' in the code.  The use of 'b' in the ValueEnv came
-from outside the case.  See Trac #4908 for the live example.
+from outside the case.  See #4908 for the live example.
 
 Note [Avoiding exponential blowup]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1786,7 +1786,7 @@ the passed-in SpecInfo, unless there are no calls at all to the function.
 The caller can, indeed must, assume this.  He should not combine in rhs_usg
 himself, or he'll get rhs_usg twice -- and that can lead to an exponential
 blowup of duplicates in the CallEnv.  This is what gave rise to the massive
-performance loss in Trac #8852.
+performance loss in #8852.
 
 Note [Specialise original body]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1827,7 +1827,7 @@ Now we want f_spec to have strictness  LLS, otherwise we'll use call-by-need
 when calling f_spec instead of call-by-value.  And that can result in
 unbounded worsening in space (cf the classic foldl vs foldl')
 
-See Trac #3437 for a good example.
+See #3437 for a good example.
 
 The function calcSpecStrictness performs the calculation.
 
@@ -1862,7 +1862,7 @@ via 'a' itself, or be in scope at f's defn.  Hence we just take
 BUT phantom type synonyms can mess this reasoning up,
   eg   x::T b   with  type T b = Int
 So we apply expandTypeSynonyms to the bound Ids.
-See Trac # 5458.  Yuk.
+See # 5458.  Yuk.
 
 Note [SpecConstr call patterns]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -1875,7 +1875,7 @@ because both of these will be optimised by Simplify.simplRule. In the
 former case such optimisation benign, because the rule will match more
 terms; but in the latter we may lose a binding of 'g1' or 'g2', and
 end up with a rule LHS that doesn't bind the template variables
-(Trac #10602).
+(#10602).
 
 The simplifier eliminates such things, but SpecConstr itself constructs
 new terms by substituting.  So the 'mkCast' in the Cast case of scExpr
@@ -1902,7 +1902,7 @@ by trim_pats.
 
 Note [SpecConstr and casts]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Consider (Trac #14270) a call like
+Consider (#14270) a call like
 
     let f = e
     in ... f (K @(a |> co)) ...
@@ -1925,7 +1925,7 @@ call patterns that
 
 I think this is very rare.
 
-It is important (e.g. Trac #14936) that this /only/ applies to
+It is important (e.g. #14936) that this /only/ applies to
 coercions mentioned in casts.  We don't want to be discombobulated
 by casts in terms!  For example, consider
    f ((e1,e2) |> sym co)
@@ -2049,7 +2049,7 @@ trim_pats env fn (SI { si_n_specs = done_spec_count }) pats
 
     emit_trace result
        | debugIsOn || hasPprDebug (sc_dflags env)
-         -- Suppress this scary message for ordinary users!  Trac #5125
+         -- Suppress this scary message for ordinary users!  #5125
        = pprTrace "SpecConstr" msg result
        | otherwise
        = result
index f391781..c627890 100644 (file)
@@ -628,7 +628,7 @@ which explodes in size when aggressively optimized. The
 -fno-cross-module-specialise option was introduced to allow users to being
 bitten by such instances to revert to the pre-7.10 behavior.
 
-See Trac #10491
+See #10491
 -}
 
 -- | Specialise a set of calls to imported bindings
@@ -793,7 +793,7 @@ What imported functions do we specialise?  The basic set is
 but with -fspecialise-aggressively we add
  * Anything with an unfolding template
 
-Trac #8874 has a good example of why we want to auto-specialise DFuns.
+#8874 has a good example of why we want to auto-specialise DFuns.
 
 We have the -fspecialise-aggressively flag (usually off), because we
 risk lots of orphan modules from over-vigorous specialisation.
@@ -1384,7 +1384,7 @@ defeated specialisation!  Hence the use of collectBindersPushingCo.
 
 Note [Evidence foralls]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
-Suppose (Trac #12212) that we are specialising
+Suppose (#12212) that we are specialising
    f :: forall a b. (Num a, F a ~ F b) => blah
 with a=b=Int. Then the RULE will be something like
    RULE forall (d:Num Int) (g :: F Int ~ F Int).
@@ -1506,7 +1506,7 @@ In general, we need only make this Rec if
 Note [Avoiding loops]
 ~~~~~~~~~~~~~~~~~~~~~
 When specialising /dictionary functions/ we must be very careful to
-avoid building loops. Here is an example that bit us badly: Trac #3591
+avoid building loops. Here is an example that bit us badly: #3591
 
      class Eq a => C a
      instance Eq [a] => C [a]
@@ -1547,7 +1547,7 @@ Solution:
 
 --------------
 Here's another example, this time for an imported dfun, so the call
-to filterCalls is in specImports (Trac #13429). Suppose we have
+to filterCalls is in specImports (#13429). Suppose we have
   class Monoid v => C v a where ...
 
 We start with a call
@@ -1785,7 +1785,7 @@ all they should be inlined, right?  Two reasons:
    This particular example had a huge effect on the call to replicateM_
    in nofib/shootout/n-body.
 
-Why (b): discard INLINABLE pragmas? See Trac #4874 for persuasive examples.
+Why (b): discard INLINABLE pragmas? See #4874 for persuasive examples.
 Suppose we have
     {-# INLINABLE f #-}
     f :: Ord a => [a] -> Int
@@ -1803,7 +1803,7 @@ So we simply drop INLINABLE pragmas when specialising. It's not really
 a complete solution; ignoring specialisation for now, INLINABLE functions
 don't get properly strictness analysed, for example. But it works well
 for examples involving specialisation, which is the dominant use of
-INLINABLE.  See Trac #4874.
+INLINABLE.  See #4874.
 
 
 ************************************************************************
@@ -2009,7 +2009,7 @@ mkCallUDs' env f args
             ClassPred cls _ -> not (isIPClass cls)  -- Superclasses can't be IPs
             EqPred {}       -> True
             IrredPred {}    -> True   -- Things like (D []) where D is a
-                                      -- Constraint-ranged family; Trac #7785
+                                      -- Constraint-ranged family; #7785
             ForAllPred {}   -> True
 
 {-
@@ -2018,7 +2018,7 @@ Note [Type determines value]
 Only specialise if all overloading is on non-IP *class* params,
 because these are the ones whose *type* determines their *value*.  In
 parrticular, with implicit params, the type args *don't* say what the
-value of the implicit param is!  See Trac #7101
+value of the implicit param is!  See #7101
 
 However, consider
          type family D (v::*->*) :: Constraint
@@ -2032,7 +2032,7 @@ So the question is: can an implicit parameter "hide inside" a
 type-family constraint like (D a).  Well, no.  We don't allow
         type instance D Maybe = ?x:Int
 Hence the IrredPred case in type_determines_value.
-See Trac #7785.
+See #7785.
 
 Note [Interesting dictionary arguments]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -2058,7 +2058,7 @@ variables?
 
 We accidentally lost accurate tracking of local variables for a long
 time, because cloned variables don't have unfoldings. But makes a
-massive difference in a few cases, eg Trac #5113. For nofib as a
+massive difference in a few cases, eg #5113. For nofib as a
 whole it's only a small win: 2.2% improvement in allocation for ansi,
 1.2% for bspt, but mostly 0.0!  Average 0.1% increase in binary size.
 -}
@@ -2117,7 +2117,7 @@ pair_fvs (bndr, rhs) = exprSomeFreeVars interesting rhs
         --         involving an imported dfun.  We must know whether
         --         a dictionary binding depends on an imported dfun,
         --         in case we try to specialise that imported dfun
-        --         Trac #13429 illustrates
+        --         #13429 illustrates
 
 -- | Flatten a set of "dumped" 'DictBind's, and some other binding
 -- pairs, into a single recursive binding.
index e8f159b..1cb02bf 100644 (file)
@@ -336,7 +336,7 @@ coreToTopStgRhs dflags ccs this_mod (bndr, rhs)
         -- It's vital that the arity on a top-level Id matches
         -- the arity of the generated STG binding, else an importing
         -- module will use the wrong calling convention
-        --      (Trac #2844 was an example where this happened)
+        --      (#2844 was an example where this happened)
         -- NB1: we can't move the assertion further out without
         --      blocking the "knot" tied in coreTopBindsToStg
         -- NB2: the arity check is only needed for Ids with External
index 6e10c98..762ec49 100644 (file)
@@ -93,7 +93,7 @@ seqBinds over the output before returning it, to ensure that there are
 no references holding on to the input Core program.
 
 This makes a ~30% reduction in peak memory usage when compiling
-DynFlags (cf Trac #9675 and #13426).
+DynFlags (cf #9675 and #13426).
 
 This is particularly important when we are doing late demand analysis,
 since we don't do a seqBinds at any point thereafter. Hence code
@@ -189,7 +189,7 @@ dmdAnal' env dmd (App fun (Type ty))
 dmdAnal' env dmd (App fun arg)
   = -- This case handles value arguments (type args handled above)
     -- Crucially, coercions /are/ handled here, because they are
-    -- value arguments (Trac #10288)
+    -- value arguments (#10288)
     let
         call_dmd          = mkCallDmd dmd
         (fun_ty, fun')    = dmdAnal env call_dmd fun
@@ -376,7 +376,7 @@ as if we had
         other      -> return ()
 So the 'y' isn't necessarily going to be evaluated
 
-A more complete example (Trac #148, #1592) where this shows up is:
+A more complete example (#148, #1592) where this shows up is:
      do { let len = <expensive> ;
         ; when (...) (exitWith ExitSuccess)
         ; print len }
@@ -596,7 +596,7 @@ dmdAnalTrivialRhs env id rhs fn
     -- Note [Remember to demand the function itself]
     -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     -- fn_fv: don't forget to produce a demand for fn itself
-    -- Lacking this caused Trac #9128
+    -- Lacking this caused #9128
     -- The demand is very conservative (topDmd), but that doesn't
     -- matter; trivial bindings are usually inlined, so it only
     -- kicks in for top-level bindings and NOINLINE bindings
@@ -726,7 +726,7 @@ The implementation is easy.  When analysing a join point, we can
 analyse its body with the demand from the entire join-binding (written
 let_dmd here).
 
-Another win for join points!  Trac #13543.
+Another win for join points!  #13543.
 
 Note [Demand analysis for trivial right-hand sides]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -743,7 +743,7 @@ Note that this can mean that 'foo' has an arity that is smaller than that
 indicated by its demand info.  e.g. if co :: (Int->Int->Int) ~ T, then
 foo's arity will be zero (see Note [exprArity invariant] in CoreArity),
 but its demand signature will be that of plusInt. A small example is the
-test case of Trac #8963.
+test case of #8963.
 
 
 Note [Product demands for function body]
@@ -1304,7 +1304,7 @@ binders the CPR property.  Specifically
    Slightly ad-hoc, because even if the scrutinee *is* a variable it
    might not be a onre of the arguments to the original function, or a
    sub-component thereof.  But it's simple, and nothing terrible
-   happens if we get it wrong.  e.g. Trac #10694.
+   happens if we get it wrong.  e.g. #10694.
 
 
 Note [Initial CPR for strict binders]
index 8f34b3b..6b98ffe 100644 (file)
@@ -185,7 +185,7 @@ f.  But that would make a new unfolding which would overwrite the old
 one! So the function would no longer be INLNABLE, and in particular
 will not be specialised at call sites in other modules.
 
-This comes in practice (Trac #6056).
+This comes in practice (#6056).
 
 Solution: do the w/w for strictness analysis, but transfer the Stable
 unfolding to the *worker*.  So we will get something like this:
@@ -240,9 +240,9 @@ will happen on every call of g. Disaster.
 Solution: do worker/wrapper even on NOINLINE things; but move the
 NOINLINE pragma to the worker.
 
-(See Trac #13143 for a real-world example.)
+(See #13143 for a real-world example.)
 
-It is crucial that we do this for *all* NOINLINE functions. Trac #10069
+It is crucial that we do this for *all* NOINLINE functions. #10069
 demonstrates what happens when we promise to w/w a (NOINLINE) leaf function, but
 fail to deliver:
 
@@ -388,7 +388,7 @@ When should the wrapper inlining be active?
    Note [Worker-wrapper for NOINLINE functions]
 
 3.