Update Trac ticket URLs to point to GitLab

This moves all URL references to Trac tickets to their corresponding
GitLab counterparts.

31 files changed, 48 insertions, 48 deletions

diff --git a/libraries/base/Control/Arrow.hs b/libraries/base/Control/Arrow.hs
index 8d910277a2..13759dbbb4 100644
--- a/libraries/base/Control/Arrow.hs
+++ b/libraries/base/Control/Arrow.hs
@@ -2,7 +2,7 @@
 {-# LANGUAGE NoImplicitPrelude #-}
 {-# OPTIONS_GHC -Wno-inline-rule-shadowing #-}
     -- The RULES for the methods of class Arrow may never fire
-    -- e.g. compose/arr;  see Trac #10528
+    -- e.g. compose/arr;  see #10528
 
 -----------------------------------------------------------------------------
 -- |
diff --git a/libraries/base/Control/Category.hs b/libraries/base/Control/Category.hs
index 37305bff1d..e8184956f2 100644
--- a/libraries/base/Control/Category.hs
+++ b/libraries/base/Control/Category.hs
@@ -4,7 +4,7 @@
 {-# LANGUAGE PolyKinds #-}
 {-# OPTIONS_GHC -Wno-inline-rule-shadowing #-}
     -- The RULES for the methods of class Category may never fire
-    -- e.g. identity/left, identity/right, association;  see Trac #10528
+    -- e.g. identity/left, identity/right, association;  see #10528
 
 -----------------------------------------------------------------------------
 -- |
@@ -16,7 +16,7 @@
 -- Stability   :  experimental
 -- Portability :  portable
 
--- http://ghc.haskell.org/trac/ghc/ticket/1773
+-- https://gitlab.haskell.org/ghc/ghc/issues/1773
 
 module Control.Category where
 
diff --git a/libraries/base/Control/Monad.hs b/libraries/base/Control/Monad.hs
index fbdb99e5f4..8223ec73d1 100644
--- a/libraries/base/Control/Monad.hs
+++ b/libraries/base/Control/Monad.hs
@@ -260,8 +260,8 @@ By contrast, the implementation below with a local loop makes it possible to
 inline the entire definition (as happens for foldr, for example) thereby
 specialising for the particular action.
 
-For further information, see this Trac comment, which includes side-by-side
-Core: https://ghc.haskell.org/trac/ghc/ticket/11795#comment:6
+For further information, see this issue comment, which includes side-by-side
+Core: https://gitlab.haskell.org/ghc/ghc/issues/11795#note_118976
 -}
 
 -- | @'replicateM' n act@ performs the action @n@ times,
diff --git a/libraries/base/Control/Monad/ST/Imp.hs b/libraries/base/Control/Monad/ST/Imp.hs
index 666b535fd0..cbcee8dd90 100644
--- a/libraries/base/Control/Monad/ST/Imp.hs
+++ b/libraries/base/Control/Monad/ST/Imp.hs
@@ -75,7 +75,7 @@ using liftST:
 
 We knew that lazy blackholing could cause the computation to be re-run if the
 result was demanded strictly, but we thought that would be okay in the case of
-ST. However, that is not the case (see Trac #15349). Notably, the first time
+ST. However, that is not the case (see #15349). Notably, the first time
 the computation is executed, it may mutate variables that cause it to behave
 *differently* the second time it's run. That may allow it to terminate when it
 should not. More frighteningly, Arseniy Alekseyev produced a somewhat contrived
diff --git a/libraries/base/Control/Monad/Zip.hs b/libraries/base/Control/Monad/Zip.hs
index 0fada6f5a2..dc192bfc81 100644
--- a/libraries/base/Control/Monad/Zip.hs
+++ b/libraries/base/Control/Monad/Zip.hs
@@ -52,7 +52,7 @@ class Monad m => MonadZip m where
     munzip mab = (liftM fst mab, liftM snd mab)
     -- munzip is a member of the class because sometimes
     -- you can implement it more efficiently than the
-    -- above default code.  See Trac #4370 comment by giorgidze
+    -- above default code.  See #4370 comment by giorgidze
 
 -- | @since 4.3.1.0
 instance MonadZip [] where
diff --git a/libraries/base/Data/Data.hs b/libraries/base/Data/Data.hs
index fa199f1117..dfa55676f6 100644
--- a/libraries/base/Data/Data.hs
+++ b/libraries/base/Data/Data.hs
@@ -1108,7 +1108,7 @@ ratioDataType = mkDataType "GHC.Real.Ratio" [ratioConstr]
 
 -- NB: This Data instance intentionally uses the (%) smart constructor instead
 -- of the internal (:%) constructor to preserve the invariant that a Ratio
--- value is reduced to normal form. See Trac #10011.
+-- value is reduced to normal form. See #10011.
 
 -- | @since 4.0.0.0
 instance (Data a, Integral a) => Data (Ratio a) where
diff --git a/libraries/base/Data/Foldable.hs b/libraries/base/Data/Foldable.hs
index 9a031212f0..037a44b99e 100644
--- a/libraries/base/Data/Foldable.hs
+++ b/libraries/base/Data/Foldable.hs
@@ -127,7 +127,7 @@ class Foldable t where
     -- and combine the results.
     foldMap :: Monoid m => (a -> m) -> t a -> m
     {-# INLINE foldMap #-}
-    -- This INLINE allows more list functions to fuse. See Trac #9848.
+    -- This INLINE allows more list functions to fuse. See #9848.
     foldMap f = foldr (mappend . f) mempty
 
     -- | A variant of 'foldMap' that is strict in the accumulator.
@@ -718,7 +718,7 @@ GHC used to proceed like this:
     in ...(c x1 y1)...(c x2 y2)....n...
 
 The trouble is that `c`, being big, will not be inlined.  And that can
-be absolutely terrible for performance, as we saw in Trac #8763.
+be absolutely terrible for performance, as we saw in #8763.
 
 It's much better to define
 
@@ -776,7 +776,7 @@ foldr1. This was problematic for space usage, as the semantics of maximumBy
 and minimumBy essentially require that they examine every element of the
 data structure. Using foldr1 to examine every element results in space usage
 proportional to the size of the data structure. For the common case of lists,
-this could be particularly bad (see Trac #10830).
+this could be particularly bad (see #10830).
 
 For the common case of lists, switching the implementations of maximumBy and
 minimumBy to foldl1 solves the issue, as GHC's strictness analysis can then
@@ -784,7 +784,7 @@ make these functions only use O(1) stack space. It is perhaps not the optimal
 way to fix this problem, as there are other conceivable data structures
 (besides lists) which might benefit from specialized implementations for
 maximumBy and minimumBy (see
-https://ghc.haskell.org/trac/ghc/ticket/10830#comment:26 for a further
+https://gitlab.haskell.org/ghc/ghc/issues/10830#note_129843 for a further
 discussion). But using foldl1 is at least always better than using foldr1, so
 GHC has chosen to adopt that approach for now.
 -}
diff --git a/libraries/base/Data/OldList.hs b/libraries/base/Data/OldList.hs
index 132ee14673..82cc9faa3b 100644
--- a/libraries/base/Data/OldList.hs
+++ b/libraries/base/Data/OldList.hs
@@ -1112,7 +1112,7 @@ and possibly to bear similarities to a 1982 paper by Richard O'Keefe:
 "A smooth applicative merge sort".
 
 Benchmarks show it to be often 2x the speed of the previous implementation.
-Fixes ticket http://ghc.haskell.org/trac/ghc/ticket/2143
+Fixes ticket https://gitlab.haskell.org/ghc/ghc/issues/2143
 -}
 
 sort = sortBy compare
diff --git a/libraries/base/Data/Typeable/Internal.hs b/libraries/base/Data/Typeable/Internal.hs
index 1be6e27b74..1775871034 100644
--- a/libraries/base/Data/Typeable/Internal.hs
+++ b/libraries/base/Data/Typeable/Internal.hs
@@ -830,7 +830,7 @@ splitApps = go []
 -- appropriate module and constructor names.
 --
 -- The ticket to find a better way to deal with this is
--- Trac #14480.
+-- #14480.
 tyConTYPE :: TyCon
 tyConTYPE = mkTyCon (tyConPackage liftedRepTyCon) "GHC.Prim" "TYPE" 0
        (KindRepFun (KindRepTyConApp liftedRepTyCon []) (KindRepTYPE LiftedRep))
diff --git a/libraries/base/Debug/Trace.hs b/libraries/base/Debug/Trace.hs
index 7f40b10156..8e15416384 100644
--- a/libraries/base/Debug/Trace.hs
+++ b/libraries/base/Debug/Trace.hs
@@ -81,7 +81,7 @@ traceIO :: String -> IO ()
 traceIO msg = do
     withCString "%s\n" $ \cfmt -> do
      -- NB: debugBelch can't deal with null bytes, so filter them
-     -- out so we don't accidentally truncate the message.  See Trac #9395
+     -- out so we don't accidentally truncate the message.  See #9395
      let (nulls, msg') = partition (=='\0') msg
      withCString msg' $ \cmsg ->
       debugBelch cfmt cmsg
diff --git a/libraries/base/Foreign/Ptr.hs b/libraries/base/Foreign/Ptr.hs
index 45e6cf5483..6a8170baea 100644
--- a/libraries/base/Foreign/Ptr.hs
+++ b/libraries/base/Foreign/Ptr.hs
@@ -110,7 +110,7 @@ Note [Exporting constructors of marshallable foreign types]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 One might expect that IntPtr, WordPtr, and the other newtypes in the
 Foreign.C.Types and System.Posix.Types modules to be abstract, but this is not
-the case in GHC (see Trac #5229 and #11983). In fact, we deliberately export
+the case in GHC (see #5229 and #11983). In fact, we deliberately export
 the constructors for these datatypes in order to satisfy a requirement of the
 Haskell 2010 Report (§ 8.4.2) that if a newtype is used in a foreign
 declaration, then its constructor must be visible.
@@ -118,7 +118,7 @@ declaration, then its constructor must be visible.
 This requirement was motivated by the fact that using a type in a foreign
 declaration necessarily exposes some information about the type to the user,
 so being able to use abstract types in a foreign declaration breaks their
-abstraction (see Trac #3008). As a result, the constructors of all FFI-related
+abstraction (see #3008). As a result, the constructors of all FFI-related
 newtypes in base must be exported in order to be useful for FFI programming,
 even at the cost of exposing their underlying, architecture-dependent types.
 -}
diff --git a/libraries/base/GHC/Arr.hs b/libraries/base/GHC/Arr.hs
index b08180d6fd..cc0397ec07 100644
--- a/libraries/base/GHC/Arr.hs
+++ b/libraries/base/GHC/Arr.hs
@@ -126,7 +126,7 @@ Note [Inlining index]
 We inline the 'index' operation,
 
  * Partly because it generates much faster code
-   (although bigger); see Trac #1216
+   (although bigger); see #1216
 
  * Partly because it exposes the bounds checks to the simplifier which
    might help a big.
@@ -151,13 +151,13 @@ is a property of the particular instances of index, bounds, and inRange,
 so GHC cannot guarantee it.
 
  * If you do (A) and not (B), then you might get a seg-fault,
-   by indexing at some bizarre location.  Trac #1610
+   by indexing at some bizarre location.  #1610
 
  * If you do (B) but not (A), you may get no complaint when you index
-   an array out of its semantic bounds.  Trac #2120
+   an array out of its semantic bounds.  #2120
 
 At various times we have had (A) and not (B), or (B) and not (A); both
-led to complaints.  So now we implement *both* checks (Trac #2669).
+led to complaints.  So now we implement *both* checks (#2669).
 
 For 1-d, 2-d, and 3-d arrays of Int we have specialised instances to avoid this.
 
@@ -787,7 +787,7 @@ There are two problems:
 2. This implementation relies on list fusion for efficiency. In order
    to implement the "amap/coerce" rule, we need to delay inlining amap
    until simplifier phase 1, which is when the eftIntList rule kicks
-   in and makes that impossible.  (c.f. Trac #8767)
+   in and makes that impossible.  (c.f. #8767)
 -}
 
 
diff --git a/libraries/base/GHC/Event/Manager.hs b/libraries/base/GHC/Event/Manager.hs
index 3ee9116812..eda3e61490 100644
--- a/libraries/base/GHC/Event/Manager.hs
+++ b/libraries/base/GHC/Event/Manager.hs
@@ -372,7 +372,7 @@ registerFd mgr cb fd evs lt = do
     when we register an event.
 
     For more information, please read:
-        http://ghc.haskell.org/trac/ghc/ticket/7651
+        https://gitlab.haskell.org/ghc/ghc/issues/7651
 -}
 -- | Wake up the event manager.
 wakeManager :: EventManager -> IO ()
diff --git a/libraries/base/GHC/Float.hs b/libraries/base/GHC/Float.hs
index 75f6f8bd68..0929421c5c 100644
--- a/libraries/base/GHC/Float.hs
+++ b/libraries/base/GHC/Float.hs
@@ -1294,7 +1294,7 @@ And with the rule:
 The running time of the program goes from 120 seconds to 0.198 seconds
 with the native backend, and 0.143 seconds with the C backend.
 
-A few more details in Trac #2251, and the patch message
+A few more details in #2251, and the patch message
 "Add RULES for realToFrac from Int".
 -}
 
diff --git a/libraries/base/GHC/IO.hs b/libraries/base/GHC/IO.hs
index 33113627a6..0c28cf0352 100644
--- a/libraries/base/GHC/IO.hs
+++ b/libraries/base/GHC/IO.hs
@@ -440,7 +440,7 @@ evaluate a = IO $ \s -> seq# a s -- NB. see #2273, #5129
 {- $exceptions_and_strictness
 
 Laziness can interact with @catch@-like operations in non-obvious ways (see,
-e.g. GHC Trac #11555 and #13330). For instance, consider these subtly-different
+e.g. GHC #11555 and #13330). For instance, consider these subtly-different
 examples:
 
 > test1 = Control.Exception.catch (error "uh oh") (\(_ :: SomeException) -> putStrLn "it failed")
diff --git a/libraries/base/GHC/Int.hs b/libraries/base/GHC/Int.hs
index d87d352cb7..3185418d54 100644
--- a/libraries/base/GHC/Int.hs
+++ b/libraries/base/GHC/Int.hs
@@ -1148,7 +1148,7 @@ instance Ix Int64 where
 
 {- Note [Order of tests]
 ~~~~~~~~~~~~~~~~~~~~~~~~~
-(See Trac #3065, #5161.) Suppose we had a definition like:
+(See #3065, #5161.) Suppose we had a definition like:
 
     quot x y
      | y == 0                     = divZeroError
diff --git a/libraries/base/GHC/List.hs b/libraries/base/GHC/List.hs
index d9b32ea9df..531669acd0 100644
--- a/libraries/base/GHC/List.hs
+++ b/libraries/base/GHC/List.hs
@@ -226,7 +226,7 @@ ensures that calls to FB functions can be written back to the original form
 when no fusion happens.
 
 Without these inline pragmas, the loop in perf/should_run/T13001 won't be
-allocation-free. Also see Trac #13001.
+allocation-free. Also see #13001.
 -}
 
 -- ----------------------------------------------------------------------------
diff --git a/libraries/base/GHC/Read.hs b/libraries/base/GHC/Read.hs
index 2283942a8f..a79f405079 100644
--- a/libraries/base/GHC/Read.hs
+++ b/libraries/base/GHC/Read.hs
@@ -383,7 +383,7 @@ readField fieldName readVal = do
 -- second argument is a parser for the field value.
 --
 -- Note that 'readField' does not suffice for this purpose due to
--- <https://ghc.haskell.org/trac/ghc/ticket/5041 Trac #5041>.
+-- <https://gitlab.haskell.org/ghc/ghc/issues/5041 #5041>.
 readFieldHash :: String -> ReadPrec a -> ReadPrec a
 readFieldHash fieldName readVal = do
         expectP (L.Ident fieldName)
@@ -420,7 +420,7 @@ readSymField fieldName readVal = do
 -- parsers. For large record types (e.g. 500 fields), this produces a
 -- significant performance boost.
 --
--- See also Trac #14364.
+-- See also #14364.
 
 
 --------------------------------------------------------------
diff --git a/libraries/base/GHC/Real.hs b/libraries/base/GHC/Real.hs
index 2a9494f5b1..8a47720fe1 100644
--- a/libraries/base/GHC/Real.hs
+++ b/libraries/base/GHC/Real.hs
@@ -295,7 +295,7 @@ never reach the condition in `numericEnumFromTo`
 
     9007199254740990 + 1 + 1 + ... > 9007199254740991 + 1/2
 
-We would fall into infinite loop (as reported in Trac #15081).
+We would fall into infinite loop (as reported in #15081).
 
 To remedy the situation, we record the number of `1` that needed to be added
 to the start number, rather than increasing `1` at every time. This approach
@@ -313,7 +313,7 @@ The benchmark on T7954.hs shows that this approach leads to significant
 degeneration on performance (33% increase allocation and 300% increase on
 elapsed time).
 
-See Trac #15081 and Phab:D4650 for the related discussion about this problem.
+See #15081 and Phab:D4650 for the related discussion about this problem.
 -}
 
 --------------------------------------------------------------
diff --git a/libraries/base/System/Environment/ExecutablePath.hsc b/libraries/base/System/Environment/ExecutablePath.hsc
index 095b25c236..2e213319bb 100644
--- a/libraries/base/System/Environment/ExecutablePath.hsc
+++ b/libraries/base/System/Environment/ExecutablePath.hsc
@@ -183,7 +183,7 @@ getFinalPath path = withCWString path $ \s ->
           | "\\\\?\\" `isPrefixOf` s = drop 4 s
           | otherwise                = s
 
-        -- see https://ghc.haskell.org/trac/ghc/ticket/14460
+        -- see https://gitlab.haskell.org/ghc/ghc/issues/14460
         rejectUNCPath s
           | "\\\\?\\UNC\\" `isPrefixOf` s = path
           | otherwise                     = s
diff --git a/libraries/base/System/Mem/Weak.hs b/libraries/base/System/Mem/Weak.hs
index 3a00696a48..8d21eb59d9 100644
--- a/libraries/base/System/Mem/Weak.hs
+++ b/libraries/base/System/Mem/Weak.hs
@@ -155,7 +155,7 @@ unreachable. There are two situations that can cause this:
 
  * If a finalizer throws an exception, subsequent finalizers that had
    been queued to run after it do not get run. This behavior may change
-   in a future release. See issue <https://ghc.haskell.org/trac/ghc/ticket/13167 13167>
+   in a future release. See issue <https://gitlab.haskell.org/ghc/ghc/issues/13167 13167>
    on the issue tracker. Writing a finalizer that throws exceptions is
    discouraged.
 
diff --git a/libraries/base/cbits/inputReady.c b/libraries/base/cbits/inputReady.c
index cfbced914f..8d100e8fbe 100644
--- a/libraries/base/cbits/inputReady.c
+++ b/libraries/base/cbits/inputReady.c
@@ -9,7 +9,7 @@
  * Thus we raise it here (before any #include of network-related headers)
  * to 1024 so that at least those programs would work that would work on
  * Linux if that used select() (luckily it uses poll() by now).
- * See https://ghc.haskell.org/trac/ghc/ticket/13497#comment:23
+ * See https://gitlab.haskell.org/ghc/ghc/issues/13497#note_140304
  * The real solution would be to remove all uses of select()
  * on Windows, too, and use IO Completion Ports instead.
  * Note that on Windows, one can simply define FD_SETSIZE to the desired
@@ -141,7 +141,7 @@ compute_WaitForSingleObject_timeout(bool infinite, Time remaining)
  * reliably on Linux when the fd is a not-O_NONBLOCK socket, so if you pass
  * socket fds to this function, ensure they have O_NONBLOCK;
  * see `man 2 poll` and `man 2 select`, and
- * https://ghc.haskell.org/trac/ghc/ticket/13497#comment:26).
+ * https://gitlab.haskell.org/ghc/ghc/issues/13497#note_140309).
  *
  * This function blocks until either `msecs` have passed, or input is
  * available.
diff --git a/libraries/base/tests/IO/hReady001.hs b/libraries/base/tests/IO/hReady001.hs
index bb7be1c78b..ef206876d6 100644
--- a/libraries/base/tests/IO/hReady001.hs
+++ b/libraries/base/tests/IO/hReady001.hs
@@ -1,6 +1,6 @@
 -- !!! hReady test
 
- -- hReady should throw and EOF exception at the end of a file. Trac #1063.
+ -- hReady should throw and EOF exception at the end of a file. #1063.
 
 import System.IO
 import System.IO.Error
diff --git a/libraries/base/tests/T11760.hs b/libraries/base/tests/T11760.hs
index 875c15916d..0582c7e37d 100644
--- a/libraries/base/tests/T11760.hs
+++ b/libraries/base/tests/T11760.hs
@@ -1,6 +1,6 @@
 -- Written by Bertram Felgenhauer
 --
--- https://ghc.haskell.org/trac/ghc/ticket/11760#comment:14
+-- https://gitlab.haskell.org/ghc/ghc/issues/11760#note_131217
 --
 -- Compile with -threaded -with-rtsopts=-N2
 
diff --git a/libraries/base/tests/fromJust.hs b/libraries/base/tests/fromJust.hs
index 2da524ffed..7c52807b42 100644
--- a/libraries/base/tests/fromJust.hs
+++ b/libraries/base/tests/fromJust.hs
@@ -1,6 +1,6 @@
 module Main where
 
--- Trac #15559: Add HasCallStack to fromJust
+-- #15559: Add HasCallStack to fromJust
 
 import Data.Maybe ( fromJust )
 
diff --git a/libraries/base/tests/genericNegative001.hs b/libraries/base/tests/genericNegative001.hs
index 7fb8192557..98457e282c 100644
--- a/libraries/base/tests/genericNegative001.hs
+++ b/libraries/base/tests/genericNegative001.hs
@@ -1,4 +1,4 @@
--- Test for http://ghc.haskell.org/trac/ghc/ticket/2533
+-- Test for https://gitlab.haskell.org/ghc/ghc/issues/2533
 import System.Environment
 import Data.List
 main = do
diff --git a/libraries/ghc-prim/cbits/atomic.c b/libraries/ghc-prim/cbits/atomic.c
index 0a471b31ad..a7d7544b4f 100644
--- a/libraries/ghc-prim/cbits/atomic.c
+++ b/libraries/ghc-prim/cbits/atomic.c
@@ -142,7 +142,7 @@ hs_atomic_and64(StgWord x, StgWord64 val)
 // See also:
 //
 //  * https://bugs.llvm.org/show_bug.cgi?id=8842
-//  * https://ghc.haskell.org/trac/ghc/ticket/9678
+//  * https://gitlab.haskell.org/ghc/ghc/issues/9678
 //
 
 #define CAS_NAND(x, val)                                            \
diff --git a/libraries/integer-gmp/changelog.md b/libraries/integer-gmp/changelog.md
index a70f214ed9..036b14cdcd 100644
--- a/libraries/integer-gmp/changelog.md
+++ b/libraries/integer-gmp/changelog.md
@@ -54,7 +54,7 @@
 
   * Reduce short-lived heap allocation and try to demote `J#` back
     to `S#` more aggressively.  See also
-    [#8647](https://ghc.haskell.org/trac/ghc/ticket/8647)
+    [#8647](https://gitlab.haskell.org/ghc/ghc/issues/8647)
     for more details.
 
   * New GMP-specific binary (de)serialization primitives added to
diff --git a/libraries/integer-gmp/src/GHC/Integer/Logarithms/Internals.hs b/libraries/integer-gmp/src/GHC/Integer/Logarithms/Internals.hs
index b8b55e486a..5f50c79e41 100644
--- a/libraries/integer-gmp/src/GHC/Integer/Logarithms/Internals.hs
+++ b/libraries/integer-gmp/src/GHC/Integer/Logarithms/Internals.hs
@@ -23,7 +23,7 @@
 -- in "GHC.Float", we must expose this module, but it should not show
 -- up in the docs.
 --
--- See https://ghc.haskell.org/trac/ghc/ticket/5122
+-- See https://gitlab.haskell.org/ghc/ghc/issues/5122
 -- for the origin of the code in this module
 module GHC.Integer.Logarithms.Internals
     ( wordLog2#
diff --git a/libraries/template-haskell/Language/Haskell/TH/Ppr.hs b/libraries/template-haskell/Language/Haskell/TH/Ppr.hs
index bc9efe6e3d..84fc740426 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Ppr.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Ppr.hs
@@ -789,7 +789,7 @@ GHC's parser only recognises a kind signature in a type when there are
 parens around it.  E.g. the parens are required here:
    f :: (Int :: *)
    type instance F Int = (Bool :: *)
-So we always print a SigT with parens (see Trac #10050). -}
+So we always print a SigT with parens (see #10050). -}
 
 pprTyApp :: (Type, [TypeArg]) -> Doc
 pprTyApp (ArrowT, [TANormal arg1, TANormal arg2]) = sep [pprFunArgType arg1 <+> text "->", ppr arg2]
diff --git a/libraries/template-haskell/Language/Haskell/TH/Syntax.hs b/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
index 690d63807c..31422a1b66 100644
--- a/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
+++ b/libraries/template-haskell/Language/Haskell/TH/Syntax.hs
@@ -255,7 +255,7 @@ unsafeTExpCoerce m = do { e <- m
 {- Note [Role of TExp]
 ~~~~~~~~~~~~~~~~~~~~~~
 TExp's argument must have a nominal role, not phantom as would
-be inferred (Trac #8459).  Consider
+be inferred (#8459).  Consider
 
   e :: TExp Age
   e = MkAge 3
@@ -912,12 +912,12 @@ function.  Two complications
 
 * In such a case, we must take care to build the Name using
   mkNameG_v (for values), not mkNameG_d (for data constructors).
-  See Trac #10796.
+  See #10796.
 
 * The pseudo-constructor is named only by its string, here "pack".
   But 'dataToQa' needs the TyCon of its defining module, and has
   to assume it's defined in the same module as the TyCon itself.
-  But nothing enforces that; Trac #12596 shows what goes wrong if
+  But nothing enforces that; #12596 shows what goes wrong if
   "pack" is defined in a different module than the data type "Text".
   -}
 
@@ -933,7 +933,7 @@ dataToExpQ = dataToQa varOrConE litE (foldl appE)
     where
           -- Make sure that VarE is used if the Constr value relies on a
           -- function underneath the surface (instead of a constructor).
-          -- See Trac #10796.
+          -- See #10796.
           varOrConE s =
             case nameSpace s of
                  Just VarName  -> return (VarE s)
@@ -1226,7 +1226,7 @@ mkName str
         --      mkName "&." = Name "&." NameS
         -- The 'is_rev_mod' guards ensure that
         --      mkName ".&" = Name ".&" NameS
-        --      mkName "^.." = Name "^.." NameS      -- Trac #8633
+        --      mkName "^.." = Name "^.." NameS      -- #8633
         --      mkName "Data.Bits..&" = Name ".&" (NameQ "Data.Bits")
         -- This rather bizarre case actually happened; (.&.) is in Data.Bits
     split occ (c:rev)   = split (c:occ) rev