Update Trac ticket URLs to point to GitLab

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

4 files changed, 16 insertions, 16 deletions

diff --git a/compiler/prelude/PrelRules.hs b/compiler/prelude/PrelRules.hs
index 3a0b1f7b9f..d9a1f8a023 100644
--- a/compiler/prelude/PrelRules.hs
+++ b/compiler/prelude/PrelRules.hs
@@ -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.
 -}
diff --git a/compiler/prelude/PrimOp.hs b/compiler/prelude/PrimOp.hs
index fd1bab3386..edadf15d4c 100644
--- a/compiler/prelude/PrimOp.hs
+++ b/compiler/prelude/PrimOp.hs
@@ -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.
diff --git a/compiler/prelude/TysPrim.hs b/compiler/prelude/TysPrim.hs
index d3fd0b949c..3e0d87fd35 100644
--- a/compiler/prelude/TysPrim.hs
+++ b/compiler/prelude/TysPrim.hs
@@ -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
diff --git a/compiler/prelude/primops.txt.pp b/compiler/prelude/primops.txt.pp
index 2740ef7455..94de07f8e5 100644
--- a/compiler/prelude/primops.txt.pp
+++ b/compiler/prelude/primops.txt.pp
@@ -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
 --