Update Trac ticket URLs to point to GitLab

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

3 files changed, 22 insertions, 22 deletions

diff --git a/compiler/stranal/DmdAnal.hs b/compiler/stranal/DmdAnal.hs
index 6e10c987a9..762ec49605 100644
--- a/compiler/stranal/DmdAnal.hs
+++ b/compiler/stranal/DmdAnal.hs
@@ -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]
diff --git a/compiler/stranal/WorkWrap.hs b/compiler/stranal/WorkWrap.hs
index 8f34b3b2ec..6b98ffe4be 100644
--- a/compiler/stranal/WorkWrap.hs
+++ b/compiler/stranal/WorkWrap.hs
@@ -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. For ordinary functions with no pragmas we want to inline the
-   wrapper as early as possible (Trac #15056).  Suppose another module
+   wrapper as early as possible (#15056).  Suppose another module
    defines    f x = g x x
    and suppose there is some RULE for (g True True).  Then if we have
    a call (f True), we'd expect to inline 'f' and the RULE will fire.
diff --git a/compiler/stranal/WwLib.hs b/compiler/stranal/WwLib.hs
index 9112ddc3bf..7b15ca7f90 100644
--- a/compiler/stranal/WwLib.hs
+++ b/compiler/stranal/WwLib.hs
@@ -214,12 +214,12 @@ Note [CPR for thunks] in DmdAnal.
 And if something *has* been given the CPR property and we don't w/w, it's
 a disaster, because then the enclosing function might say it has the CPR
 property, but now doesn't and there a cascade of disaster.  A good example
-is Trac #5920.
+is #5920.
 
 Note [Limit w/w arity]
 ~~~~~~~~~~~~~~~~~~~~~~~~
 Guard against high worker arity as it generates a lot of stack traffic.
-A simplified example is Trac #11565#comment:6
+A simplified example is #11565#comment:6
 
 Current strategy is very simple: don't perform w/w transformation at all
 if the result produces a wrapper with arity higher than -fmax-worker-args=.
@@ -483,7 +483,7 @@ To avoid this:
 
   * We use a fresh unique for both type-variable and term-variable binders
     Originally we lacked this freshness for type variables, and that led
-    to the very obscure Trac #12562.  (A type variable in the worker shadowed
+    to the very obscure #12562.  (A type variable in the worker shadowed
     an outer term-variable binding.)
 
   * Because of this cloning we have to substitute in the type/kind of the
@@ -621,7 +621,7 @@ unbox_one dflags fam_envs arg cs
                                          data_con unpk_args
                 arg_no_unf = zapStableUnfolding arg
                              -- See Note [Zap unfolding when beta-reducing]
-                             -- in Simplify.hs; and see Trac #13890
+                             -- in Simplify.hs; and see #13890
                 rebox_fn   = Let (NonRec arg_no_unf con_app)
                 con_app    = mkConApp2 data_con inst_tys unpk_args `mkCast` mkSymCo co
          ; (_, worker_args, wrap_fn, work_fn) <- mkWWstr dflags fam_envs False unpk_args
@@ -836,7 +836,7 @@ the case on `x` up through the case on `burble`.
 Note [mkWWstr and unsafeCoerce]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 By using unsafeCoerce, it is possible to make the number of demands fail to
-match the number of constructor arguments; this happened in Trac #8037.
+match the number of constructor arguments; this happened in #8037.
 If so, the worker/wrapper split doesn't work right and we get a Core Lint
 bug.  The fix here is simply to decline to do w/w if that happens.
 
@@ -875,10 +875,10 @@ opportunities for optimisation.
 
 Solution: use setCaseBndrEvald when creating
  (A) The arg binders x1,x2 in mkWstr_one
-         See Trac #13077, test T13077
+         See #13077, test T13077
  (B) The result binders r1,r2 in mkWWcpr_help
          See Trace #13077, test T13077a
-         And Trac #13027 comment:20, item (4)
+         And #13027 comment:20, item (4)
 to record that the relevant binder is evaluated.
 
 
@@ -901,13 +901,13 @@ can still be specialised by the type-class specialiser, something like
 BUT if f is strict in the Ord dictionary, we might unpack it, to get
    fw :: (a->a->Bool) -> [a] -> Int# -> a
 and the type-class specialiser can't specialise that.  An example is
-Trac #6056.
+#6056.
 
 But in any other situation a dictionary is just an ordinary value,
 and can be unpacked.  So we track the INLINABLE pragma, and switch
 off the unpacking in mkWWstr_one (see the isClassPred test).
 
-Historical note: Trac #14955 describes how I got this fix wrong
+Historical note: #14955 describes how I got this fix wrong
 the first time.
 -}
 
@@ -1030,7 +1030,7 @@ mkWWcpr_help (data_con, inst_tys, arg_tys, co)
                 , \ wkr_call -> Case wkr_call arg (exprType con_app) [(DEFAULT, [], con_app)]
                 , \ body     -> mkUnpackCase body co work_uniq data_con [arg] (varToCoreExpr arg)
                                 -- varToCoreExpr important here: arg can be a coercion
-                                -- Lacking this caused Trac #10658
+                                -- Lacking this caused #10658
                 , arg_ty1 ) }
 
   | otherwise   -- The general case
@@ -1115,7 +1115,7 @@ The idea is that this binding will never be used; but if it
 buggily is used we'll get a runtime error message.
 
 Coping with absence for *unlifted* types is important; see, for
-example, Trac #4306 and Trac #15627.  In the UnliftedRep case, we can
+example, #4306 and #15627.  In the UnliftedRep case, we can
 use LitRubbish, which we need to apply to the required type.
 For the unlifted types of singleton kind like Float#, Addr#, etc. we
 also find a suitable literal, using Literal.absentLiteralOf.  We don't