Eliminate default-inits arg from make-record-type.

This will allow all optional args to be removed after 9.3.

Streamline definition of record-type proxies.

Allow a record to be both applicable and fasdumpable.

Restrict access to type proxies.

Change default value of repl:write-result-hash-numbers? as requested by GJS.

Change pathname representation to be a fasdumpable record.

Use proxy instances for set-record-type-fasdumpable!.

Fix typo in previous change.

Implement fasdumpable records.

This is restricted to the runtime system since each type must have a
pre-allocated constant to represent it in the proxy table.

At the moment an applicable record can't be fasdumpable too.  That can be fixed
by teaching the microcode about the proxy mechanism, but for now it's not
necessary.

In pp, treat named list/vector specially.

Use cached predicate dispatchers only where tagging is ubiquitous.

Implement applicable records.

Change representation of dispatch tags to eliminated nested "extra" vector.

Eliminate two unused procedures.

Guarantee that capture-syntactic-environment preserves error context.

Some more tweaks to the low-level macro interfaces.

Implement first two macros using syntax-parser.

More tweaks to syntax-parser interface.

Tweak interface for syntax-parser macros.

Refactor syntax-low to improve support for spar transformers.

Eliminate a bunch of now-unused classifier procedures.

Split compile-expr-item into expr and non-expr versions.

Add weak-pair support to equal?.

Add call/cc as alias.

Allow calling register-predicate! twice with the same args.

Put back support for printing tagged lists and vectors when built by 9.2.

Make sure that tagged vector/pair predicates are registered.

Change compiled-code environments to be records.

Put error messages back into classifiers.

Also:
* Clean up spar API some more.
* Add spar-error for signalling errors.
* Add special args for specifying procedure args.

Rename spar-require-X to spar-match-X.

Make sure to flatten items in a body.

Rewrite mit-syntax using syntax parsers.

This is functionally equivalent except for error reporting.  Most syntax errors
will be "ill-formed syntax" with a form.  An future commit will tailor the
messages to be more informative.

This also breaks one syntax test, which will be fixed in the next commit.

Another round of changes to the spar API.

Fix thinko.

Implement spar-macro-transformer.

Split transformer->expander procedures into internal and external.

The external version takes a runtime environment as its closing env, while the
internal version takes a syntactic environment.

Merge classifier and keyword items.

A round of updates to the syntax parser.

Add syntax-parser to runtime; not yet being used.

Refactor the syntax-error mechanism.

* There's now a condition type for syntax errors.
* There's a distinction between errors that happen in macro expanders and those
  that happen inside the syntax implementation.
* All syntax errors now get the (form senv hist) objects.
* Syntax errors don't yet use the history to report context; that will come
  later.

Eliminate keyword-binder.

Make field-names argument of condition-constructor be optional.

When that happens it uses the type's field-names value.

Simplify slightly be introducing smap.

decl-item doesn't need to be distinct from expr-item.

Make sure history is correct for identifiers in declarations.

Plumb selectors through map-decl-ids and pass to procedure.

Reorganize cold-load for syntax.

* Rename syntax-transforms to syntax-low.
* Move expander-item to syntax-low.
* Don't load syntax-items early in cold load.
* Move compile-expr-item to syntax-items.

Bind classifiers directly into global environment.

Eliminates kludge of syntax-definitions.

Eliminate compile-body-item and simplify.

Minor tweaks to classifiers.

Rename classify-body to classify-forms-in-order.

Also have it return a list of items rather than a seq-item.

Some minor tweaks that were missed in earlier commits.

Eliminate compiler items.

Eliminate compiler->keyword.

Eliminate the remaining three compilers.

Change most of the "compilers" to "classifiers".

This is the first step in eliminating the idea of a "compiler".

Insert a reduction step in the history when processing a closed subexpression.

Implement history mechanism for syntax processor.

This mechanism keeps track of how each subexpression is derived from the larger
program, so that error messages can have that context.

The history isn't yet hooked up to anything; it's just being tracked.  The next
step is to attach it to the syntax errors and change the error messages to
reveal that context.

Make sure that host-adapter causes rebuild of toolchain.

Also always load the .scm file since the compiled files may be out of date.

Rewrite this file to match current standards.

Revert change that broke the build.

Another small round of renaming.

Eliminate now-unused output/lambda and rename output/{named-,}lambda.

Some minor cleanups.

Downcase explicit arguments to syntax-check and syntax-match?.

Also replace '(keyword ...) -> '(_ ...) in syntax-check patterns.

Implement classify-form-cXr to simplify code slightly.

This will be more important when history is added.

Rename environment to senv in mit-syntax.

Eliminate classify-expr.

A big round of renamings.

Change predicate dispatchers to use dispatch cache.

Eliminate keyword-value-item.

A bunch of renames to eliminate weird "/" phase of mine.

Collapse syntax, syntax-classify, and syntax-compile into one file.

Make comment in identifier=? more comprehensive.

Move the higher-level senv procedures into syntax-environments.

* Clean up the high-level interface, making arg order consistent.
* Rename syntactic-environment->environment as syntactic-environment->runtime.
* Eliminate ->syntactic-environment in favor of runtime-environment->syntactic.
* Rename syntactic-environment/top-level? to top-level-syntactic-environment?.
* Export closed-identifier? to (runtime syntax).

Implement better pp support for syntactic environments.

This should be a standard pattern: what's interesting in these bundles of
procedures isn't the procedures themselves, but rather the state they are
carrying around.

Don't generate keyword-value-item except at top level.

They aren't needed for internal environments.

Handle define-syntax better when unsyntaxing.

Fix test broken by earlier change.

Eliminate another empty file.

Simplify how runtime syntactic environments are created.

No more layering of top-level environments over one another, or of top-level
environments over runtime environments -- a top-level environment IS a runtime
environment.

Don't use syntactic enviroment to indirectly bind global macros.

Remove empty file.

Add bindings for the block-declaration renames.

Change declaration processing to decouple it from open blocks.

Rename block-declaration -> scode-block-declaration and move to "scode".

Change seq-item to flatten its arguments.

Also rename flatten-seq-items to flatten-items.

A large number of renames for syntax items.

Eliminate unnecessary condition.

Don't use binding-item for LET bindings.

Change syntactic environments to be records rather than bundles.

It's not using the bundle functionality so there's no advantage.

Change define-bundle-interface to use quote-identifier.

Implement quote-identifier, which is needed for macro-generating macros.

I'm not entirely happy with this; it feels like a wart.  But I don't see an
alternative at the moment.

Rename combinator-substitution -> list-substitution.

Fix but: top-level definition names must be symbols.

Disallow runtime environments in make-syntactic-environment.

Simplify the rename-db implementation.

Eliminate synthetic identifiers.

Now identifiers are either symbols or closures over symbols.  Any operation on a
closed identifier redirects to the appropriate environment, rather than trying
to bind and/or lookup the closure itself in the environment.

This greatly simplifies the identifier model, and makes the operation of the
syntax processor much clearer.

Change compile-item/expression to be a predicate dispatcher.

Also, a bunch of small changes, mostly cleanups and simplification.

Simplify interface to syntax renaming.

Reorganize the code within syntax-rename.  No other changes.