Avoids recording original syntaxes with a source or position
of #f, since these are usually intermediate syntax pairs that
don't correspond to actual source syntax.
For example, in a (#%module-begin . rst) in a submodule, the
underlying pair may contain an identifier and a cdr that is a
syntax object. That cdr will have #f source and position and also
does not correspond to any source syntax.
Leaving such syntax objects in the table means there are spurious
hits later when a syntax object with an unknown source location
is looked up.
Closes PR 14389
free-identifier=? expects, contrary to documentation, a syntax?, causing
contract errors. (and (identifier? ...) ...) solves this.
[Since the function is called only on fully expanded forms, it doesn't
look like the `identifier?` tests can ever fail, but it still seems
sensible to have them. -Matthew]
Use `call-with-` instead of `with-`, since it's a function instead
of a syntactic form. (This is a weak convention, but one to try to
follow with new functions and forms.)
Fix up the contracts and change the documentation to match the
usual style.
Create the temporary directory in `(find-system-path 'temp-dir)`
instead of the current directory.
Previously, relative locations were preserved for all files with the same
root, but that tends to keep too much information about the original
filesystem layout, especially when runtime files are pulled both from
the installation and a user-specific area. Since packages can be installed
at different relative locations, it makes sense to preserve relative
locations only up to package boundaries.
Commit 5ea4c2ab68 broke GCing of a thread that is blocked
via `sync` (as opposed to `place-channel-get`) on a place
channel whose write end is inaccessible.
If a package installed as a link in user scope, then removed, then
linked again, the documentation index database was not updated
correctly. As a result, the user-specific documentation page was
either not updated or had a broken link for the document.
TR no longer needs to handle #<undefined> because the value
no longer leaks out from uninitialized variables. However, uses
of uninitialized variables are not caught by TR (they are treated
like errors from the `error` function).
a function to get more interesting values and then use those values
to guarantee it can generate things it couldn't before
For example, it can now generate a function with this contract:
(-> (-> is-eleven?) is-eleven?)
without knowing what the is-eleven? predicate does -- instead it can
figure out to call the argument thunk and then pipe that result around
