It does not use a platform-specific time.

Use `@tech{the epoch}` for `current-inexact-milliseconds`, too.

Close #4622

A stray extra space broke version parsing.

When the kernel escapes with an error, it's meant to release all of
its acquites on the tc mutex, but changes in f1f4959b removed
a counter that distinguishes kernel acquires from Scheme acquires.

A test for this is part of a subsequent `gensym->unique-string`
commit, since `gensym->unique-string` takes a mutex around the call to
a kernel function that errors.

The comment was about an implementation that hash been replaced by
`list-assuming-immutable?`.

Thanks to @elibarzilay.

This allows macros and tools to treat code within a class body differently. The primary use case for this information is in Resyntax, particularly https://github.com/jackfirth/resyntax/issues/186.

This commit strengthens the wording a bit. See prior conversation in 09f74002 and https://github.com/jackfirth/resyntax/issues/191.

Closes #4611

Chez Scheme's tracer will log the output of all passes if `#t` is supplied as a
pass name to log. This wires that up to Racket's linklet-level
`PLT_LINKLET_SHOW_PASSES` env var via the special pass name `all`.

Closes #4607

The system-supplied library as of Monterey is 0.9.8 or 0.9.7, which
triggers a warning from "mzssl.rkt" while building at the point where
`raco pkg install` is trying to download packages, including the
"racket-lib" package that supplies OpenSSL. Change the search to look
specifically for the library version that is part of the "racket-lib"
package; `raco pkg install` will fall back to the CoreFoundation API
during the initial install.

It has been possible to supply a Chez Scheme for bootstrapping via configure
args (`--enable-scheme`) for some time, but it was not clear how to do so if
using the top-level makefile. This wires up that support in a similar way to the
existing `RACKET`-related makefile options.

This bug was hidden by the way that syntax-parse usually compiles
calls to syntax-classes ("the commit protocol"), but that should be
considered an optimization, not necessary for correct behavior.

Previously, it saved the entire original use of `syntax-parse` (etc) as
a syntax constant for run-time error reporting, expensive in terms of
code size.  Thanks Matthew for the suggestion.

Closes #4601

Put the `top-link` field the same distance from the end of a compact
rp header and a non-compact rp header. That way, the GC can avoid an
indirection finding code as it traverses a continuation. This can save
collection time on some x86_64 (such as an Intel MacBook) for a
program that captures and saves many continuations, like the one
below.

(define (go)
  (define (make-one)
    (call/cc
     (lambda (esc)
       (let loop ([i 1000])
         (if (zero? i)
             (call/cc esc)
             (+ i (loop (sub1 i))))))))

  (define l
    (let loop ([i 1000])
      (if (zero? i)
          '()
          (cons (make-one)
                (loop (sub1 i))))))

  ;; quadratic-time traversal that creates continuations
  ;; with a spectrum of lifetimes
  (let loop ([l l])
    (unless (null? l)
      ;; replace all in this `l`
      (let loop ([l l])
        (unless (null? l)
          (set-car! l (make-one))
          (loop (cdr l))))
      ;; recur with the rest of `l`
      (loop (cdr l))))

  ;; keep the original list, so we retain the
  ;; continuatons
  l)

(time (begin (go) (void)))

When a string pattern is converted internally to a byte-string
pattern, the need for backtracking can change, since "." expands
to a pattern that can match varying lengths.

Closes #4596

The cptypes pass was intended to improve run-time performance, and it
somtimes helps a lot, but measurements on realistic programs suggest
that run-time improvements are typically modest. Furtunately, compile
time tends to benefit from the extra pass, even when run time doesn't,
so it's an easier call to have it enabled by default.

Provide link to 21.1 Running racket and gracket

so that it doesn't ignore values after the first one