Allow hyphens in filenames.

Now that we do the ‘files()’ FSA thing correctly, we can tolerate otherwise-very-special characters.
We don’t allow file(foo) within files() any more.
Add (failing) tests for higher-order functions.

Now we should go ahead and implement these things...
Actually, we might try to format a Structure.

The result should just be an empty string.
An identifier isn’t an expression, a reference is.

This distinction will become more important in a minute when I fix call targets referenced as field accesses.
Only use catch-all in release mode.

When debugging, we want uncaught exceptions to propagate all the way up so that the debugger will catch them.
A FieldAccess’s base should be a SymbolReference.

The base of a field access isn’t an arbitrary expression: it’s an expression that refers to a symbol.
Don’t look for SourceRange of deleted Identifier!

Also reduce a little redundancy in the building of a SymbolReference.
SymbolReference base might not be an Identifier.

At the moment it always is, but in the future it might be other things (e.g. a field access).
#include “AST/Value.h” in “AST/Scope.h”.

Consumers of fabrique::ast::Scope may need the definition of Scope, so let them see it.
A field access is itself a symbol reference.

It’s not just an arbitrary expression, it’s an expression that is used to reference a symbol (defined in the structure).
Refactor scope-owning into ast::HasScope.

We will want more things to be the base of FieldAccess nodes (and possibly, more generally, to be things that have a scope).
Trivial: improve dag::Structure::PrettyPrint.
Add dag::Structure::field() and operator[].

Sometimes we need to access a Structure’s fields...
Add support for multi-component symbol names.

We can now support symbol references like ‘foo.bar.wibble’.
Add fabrique::dag::Function.

We want to be able to pass functions around, so we need a dag::Value to hold them. Right now, this object just keeps a reference to an ast::Function, which is safe because the AST lives at least as long as the DAG. It’s not a very satisfying construction, however: maybe we want to use shared_ptr / weak_ptr in the AST?
Add ast::Expression::definition().

Most expressions are self-defining, but others (e.g. SymbolReference) refer to other definitions.
Say when a type is a function type.
Implement FunctionType::isSubtype().

Allow function types to be compared in a type hierarchy so that we can, e.g., decide whether or not a function can be assigned to a value.
Parse function types, too.