Apply replacement to variable declaration components in VariableResolver

This got missed on cb8ee1f.

Complain about named interface blocks if not supported

Report unsupported shader errors through the diagnostic mechanism

Easier way of adding complex subtrees to GLSL debug dump

Add another variation of a partially unused interface block

I discovered a case where the compiler behaves incorrectly so recording
it here.

Further refactor the resolving process in SL::Compiler

There's now five different types of resolve operations, many of which
depend on some others.  Better put the logic in one place to keep it
straight.

This also includes some rearrangements to the resolver classes to have
all of them return a boolean indicating if anything was done.

Additional rules for bit shift operators

Properly resolve arithmetic assignment operators

After 50ab5ca operations like vec3 *= float were failing because the
validator required both operands to be of the same type.  Conversions
also need to be resolved for the right-hand operand.

Rearrange expression node replacement

Rather than every expression visiting function clearing the replacement
result, clear it in the replacement function both before and after.  This
is more compact and less prone to forgetting it from somewhere.

Refactor resolution of declarations for MemberAccess

Now that expressions have types, there's no need to "return" the members
from deeper in the hierarchy anymore.

Since member type resolution now depends on the type of the left-hand
expression of MemberAccess, variables and expressions need to be resolved
in a loop until there's nothing more to resolve.

Remove fallback from Assignment to BinaryExpression in TraversingVisitor

It's causing some trouble when the base class version is called for an
assignment and it gets handled as a binary expression.  Almost all classes
are handling the two separately anyway.

Remove an unnecessary loop over block hierarchy

Add some test cases for unused interface blocks

Fix a type error in a test case

Assign a result type to all expressions

This requires some additional work for function overloads and swizzles.

Remove a debug thing

Ignore precedence for prefix operators

Since the operator appears at the start of an expression or after another
operator, there's no way for it to bind to anything but whatever follows.
This fixes a bug where chained prefix operators were not recognized.

Create array type declarations as necessary

Tweak the builtin type generation

Give bool a size and insert the types in the order they're defined in.

Store actual values for literals

Visit structs during unused type removal

Otherwise types which are only used by struct member declarations would
be removed.

Mark function return types as used

Actually call the type validator

Check that errors were generated as expected

Follow type aliases in TypeResolver

Use resolved type names for output

Resolve the return types of functions

Validate some aspects of type declarations

Catch exceptions from parsing while testing the compiler

Fix a bug with resolving member declarations

The logic changes in 7daccf2 caused members of variables declared within
anonymous interface blocks to not be resolved correctly.

Fix a memory error with interface blocks

The changes in d72d8a9 were not applied to the interfaces map of the
stage, but because those interfaces were unused anyway it only showed
up when doing an AST dump.

Remove unused type declarations from GLSL during optimization

The biggest impact of this right now is keeping the AST dump manageable.

Copy location when creating an interface block reference

Allow AST to be dumped even if compilation fails

Check that variable references refer do declared variables

Give declaration nodes to all GLSL types.

Even the builtin ones.  This makes various operations with expressions
easier and helps with SPIR-V.

Record location information in all syntax nodes

Validate struct name uniqueness

Make builtins const

Load builtin GLSL declarations from a file

I'm going to add a lot more stuff into it so having it in the C++ source
would be inconvenient.

Use a different method of adding builtins to stages

This gets them in the correct order with the module's shared stage, and
also allows builtins to have shared declarations.

Add a missing symmetry to linking variables

This caused invalid memory accesses when destroying syntax trees.

Only set assign_to_subfield when in assignment target

Check for function declaration conflicting with something else

Functions are allowed to have multiple declarations but only one
definition.

Improve rules for interface blocks

The GLSL specification says that using the same block name in different
interfaces is allowed, so we must separate blocks by interface.

Check for missing lines in error output

Use insert instead of [] to retain the first item with the same name

Add some test cases to test shader validation

Make the GLSL compiler tester able to verify errors

Use the new append utility function to build GLSL compile errors

Flip the parameters of Tokenizer::begin

Everything else has the filename as the last parameter, so let's be
consistent here.

Remove a redundant declaration of shadow_coord

This is declared in shadow.glsl

Copy the location when moving output declarations out of functions

Have generate_interface return the generated statement

Add basic validation to the GLSL compiler

Currently the only thing validated is multiple definitions.

Remove unnecessary includes

Fix function inlining in iteration init statement

Also reword the other related comment to be more accurate.

Update .gitignore

Remove some old build products and add glslcompiler.

Add the shader for UnlitMaterial

This was supposed to be in 2f198e3

Add extension file for NV_half_float

This should have been in 9087cc0 but went unnoticed for a month due to
how the extension headers are handled.

Add a unit test framework and some tests for the GLSL compiler

Some of the tests fail due to bugs in the compiler.

Add expression inlining

Make the iteration init statement a Statement instead of Node

Add a new associativity type for fully associative operators

Add some comments to the more complex parts of the GLSL compiler

Visit iteration statement components in semantically correct order

Minor, largely cosmetic tweaks

Remove some unnecessary bits

Fix an issue where member assignments were incorrectly optimized away

They are now treated as subfield assignments, same as array subscripts.

Don't copy type declaration of a generated interface variable

It's better to let it be resolved again.

Fix VariableResolver doing bogus things on certain invalid constructs

Fix passthroughs being generated for non-output variables

Rename members of visitors to indicate which are "return values"

Handle all constructs when inlining GLSL functions

We need to look for function calls inside conditional and iteration
statements too, and inline calls within condition expressions.

Fix a block management error in FunctionInliner

Add a missing #include

This was left out from d5c7c7f

Store a pointer to operator info rather than the token in expressions

Also make it a property of Expression rather than the subtypes.

Further improve inlining of GLSL functions

Functions of any lenght can now be inlined, as long as they have linear
control flow.

Clear previous state when resolving functions

Remove expression statements without side effects

Fix another case of future features leaking

Fix an issue with line numbers after #line being off-by-one

I had added the flag for this back in 1083ad1 but forgot to use it.

Explicitly call base class copy constructor for expressions

Refactor FunctionInliner to do any necessary declaration reordering

Clarify SL::Compiler::optimize return values by using an enum

Inject builtins into the module

This makes identifier resolution easier to manage and also helps an
eventual SPIR-V implementation.

Debug output tweaks

Clear the stage map at the beginning if a resolving pass

This avoids accidentally resolving things to a declarations which is not
visible to the reference.

Remove things that weren't supposed to go in yet

Store functions definitions in Stage

Move function override processing to FunctionResolver

Make the GLSL parser resilient against common errors

It will now attempt to continue parsing the source, with the intent of
reporting all syntax errors at once.

Add some documentation to the GLSL compiler

Fixes for compatibility with legacy unsized PixelFormats

Don't copy layouts to generated out interfaces

Use specialization constants in the builtin material shaders

This has the side effect that RenderPass now requires a collection
to use the builtin shaders.

Add interfaces for using specialization constants with Programs

This replaces the old way of redefining variables withing the GLSL
source, and as such the Program constructor from string is now
deprecated.

Support specialization constants in the GLSL compiler

Mostly cosmetic tweaks

Copy layouts when generating interfaces