Record correct source information in interface layout statements

Show node source locations in AST dump

Rename DeclarationValidator to IdentifierValidator

This name more accurately describes what it does.

Support layout qualifiers on GLSL interface blocks

Rename InterfaceBlock::name to block_name for clarity

Add push_back_nocopy to NodeContainer for clarity

It's not immediately obvious that pushing null and then assigning avoids
cloning the node.

Add idempotence test cases for GLSL compiler

Already compiled GLSL code should not change when passed through the
compiler again.

Refactor the GLSL compiler test cases with a helper class

I'm not super pleased with the virtual fail function in the helper, but
no better ideas came to mind so it can be like that for now.

Always show shader compiler diagnostics in debug builds

Forbid certain operations in SL::Compiler if compilation isn't done

In particular, Formatter can't deal with unresolved declarations.

Adjust naming of generated variables

Using the inlined function name as a prefix easily produces inconsistent
results, so better to just use numbers after the name.

Test case tweaks

Support inlining GLSL functions with parameters

Refactor variable renaming in InlineContentInjector once again

It should now be even better at recognizing conflicts, and avoid renaming
when not necessary.

Use a temporary staging block in InlineContentInjector

This allows the return variable name generation to avoid other names from
the source function, such as a return variable from previous inlining.

Remove an obsolete variable

This hasn't been used since 0388083.

Don't modify the target block's variable map from InlineContentInjector

This felt hacky, and also seemed wrong since the variable map contains
the original names of the variables, not new ones.  Instead avoid
inlining more than one function per pass into any given function.

Check that the types of ternary branches exist before accessing them

This fixes a bug introduced in 3a1fe83 and triggered by 5e4204e.

Eliminate constant ternary expressions

Implement constant folding in the GLSL compiler

This replaces the old expression evaluator with a more comprehensive
solution.  Folding constant expressions may open up further possibilities
for inlining.

Fix the declaration of the builtin textureLod function

Fix some bugs with name conflicts in function inlining

One of these is a regression from b89239e, but the other has been around
for longer.

Resolve and validate the parameters of constructors in GLSL

Make variable renaming while inlining more robust

It now prevents accidentally hiding global variables too.

Move unique name generation to syntax.cpp

It's going to be needed elsewhere too.

Resolve constructors in FunctionResolver

Remove the ParenthesizedExpression node type

Since this is a proper compiler now, it's no longer necessary to
reproduce the parentheses from the input.

Cleanup ExpressionInliner

Move parenthesizing expressions to Formatter

Rearrange operator metadata

A secondary token can now be stored for the operators that need one.

The member access operator is categorized as postfix because it only has
one actual operand (the right-hand side is just an identifier).

Better error message for the subscript operator

Add GLSL keywords for overriding functions

Overriding with a plain redefinition is now deprecated.

Fix some errors in the shader library

Don't require builtin inputs to be linked

Many of them provide access to external values from the API.

Add declarations for some more builtin variables

Avoid generating passthroughs for builtin variables

Make it deprecated to redeclare non-builtin variables

This is no longer necessary now that specialization constants are
supported.  There's some additional rules for declaring builtins too,
but I'll get back to those later.

Handle redeclaration of variables in VariableResolver

Add missing Diagnostic constructor

This is needed by the changes in 16c02e4.

Implement the ternary operator in GLSL

Refactor Parser::parse_expression to take a pointer to the outer operator

Limit GLSL passthrough statement to variables declared by that point

This fixes an issue where a base module's passthrough statement would
generate references to inputs declared in an importing module, resulting
in a compile error.

Fix a test case and add a couple more

Improve reporting of errors from function resolution

If there are some overloads, report that none of them matched the
argument types.

Avoid generating invalid interfaces in geometry shader

Geometry inputs need an extra array dimension compared to vertex shader
outputs, but multi-dimensional arrays currently can't be properly
represented.

Expand the selection of available builtin GLSL functions

Some rearranging and comments

Count EmitVertex as referencing all active outputs

Rewrite UnusedVariableRemover

The old implementation was getting too complex with its multitude of
flags.  The new one is based on the idea of reaching definition analysis
and is much more straightforward.

Don't omit builtins when formatting a single node

This produces more useful output for debugging.

Make ConstantConditionEliminator less trigger-happy

Since I removed the variable value tracking in 1cd0ea7 it started
optimizing conditions on specialization constants, even when they
had not been specialized yet.

Check for existence of required version in Formatter

This way it doesn't depend on whether get_combined_glsl or get_stage_glsl
was called.

Support compile modes and specialization constants in the test harness

Avoid removing outputs which are referenced but not assigned

The values from such reads are undefined but the variables should be
kept nevertheless.

Rename and rearrange a few things

Require GLSL functions to be declared before use

Add declarations for most of the builtin functions in GLSL

Validate return types of overloaded functions

Add support for function overloading

Resolve functions after inlining functions

Inlining clones expressions, and the clones FunctionCall nodes don't have
a declaration pointer.

Properly use r_any_resolved in FunctionResolver

Apparently lacking this has not caused any trouble so far, but it would
soon.

Handle expression replacement through TraversingVisitor

There were several cases missing, like VariableResolver not handling
replacement of swizzles in return statements.  This way each of the
visitors can just concentrate on what they're actually doing.

Use accurate assignment targets in ExpressionInliner

This fixes an issue where it inline an assignment to a subfield in place
of a reference to the whole variable.

Refactor UnusedVariableRemover

It can now track and remove named interface blocks.

Record assignment targets more precisely

If the assignment is to a structure or vector field or an array element,
it's recorded to the node so optimizers can better match assignments and
references (they don't do that yet).

Sort diagnostics according to their provoking location

Record information of the provoking location of a diagnostic

In case of diagnostics providing extra information to a previous one,
this can be different from the direct location.

Validate member names

Fix some errors in test cases

Recognize swizzles in GLSL

Resolve functions after inlining expressions

This fixes a bug introduced in c1d3a1d.

Transform interface block contents into structs

This allows handling them in expression trees like everything else.  It
also helps with SPIR-V, which requires interface blocks to have struct
types.

Remove the NodeGatherer visitor

It was somewhat poorly thought out since it's unable to gather nodes of
a base class type.

Populate the builtin module's type maps directly

TypeResolver may do other, potentially disruptive things.  The contents
will be copied into the compiled module and properly resolved there.

Improve reporting of function name conflicts

Prototype declarations were not being recorded, and definitions were
causing multiple definition errors to be reported in double.

Check for extra error lines in compiler output

Somehow I thought this was handled already

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