In compaction, remove unused anonymous overrides.
Since overrides are no longer used by definition, include override
initialization expressions in the tandem traversal of types and global
expressions.
To simplify overload processing, we plan to make all override-sized
arrays refer to their lengths via actual `Override`s. Arrays with
non-identifier override expressions as their lengths would refer to
anonymous `Override`s with interesting `init` expressions. But in
order to avoid re-introducing #6788, we need compaction to remove
anonymous overrides.
Rather than reversing two iterators and then zipping them, zip them
first and then reverse the result.
However, zipped iterators are only reversible if the inputs implement
`ExactSizeIterator`, so make `UniqueArena::iter` promise that as well.
For consistency, make `Arena::iter` also promise to return an
`ExactSizeIterator`.
Add `hashbrown` with the `"serde"` feature as a development dependency
for Naga. Regardless of whether Naga's `deserialize` feature is
enabled, the snapshot tests need to deserialize parameters saved in
files as RON text.
It would also suffice to use `std::collections::HashSet` in the
snapshot tests, although we would need to build a `naga::FashHashSet`
from the std `HashSet` at one point. Adding the dev-dependency seems
slightly simpler.
Fixes#7038.
eval_zero_value_and_splat() is called to lower ZeroValue and Splat
expressions into Literal and Compose expressions. However, in its
current form it either calls splat() *or* eval_zero_value_impl()
depending on the expression type.
splat() will lower a Splat of a scalar ZeroValue to a vector
ZeroValue, which means eval_zero_value_and_splat() can still return a
ZeroValue. Its callers, such as binary_op(), are unable to handle this
ZeroValue, so cannot proceed with const evaluation.
This patch makes it so that eval_zero_value_and_splat() will first
call splat(), *and then* call eval_zero_value_impl(), which will lower
the vector ZeroValue returned by splat() into a Compose of Literals.
Callers such as binary_op() are perfectly able to handle this Compose,
so can now proceed with const evaluation.
It's currently trivial to write a shader that causes the wgsl parser
to recurse too deeply and overflow the stack. This patch makes the
parser return an error when recursing too deeply, before the stack
overflows.
It makes use of a new function Parser::track_recursion(). This
increments a counter returning an error if the value is too high,
before calling the user-provided function and returning its return
value after decrementing the counter again.
Any recursively-called functions can simply be modified to call
track_recursion(), providing their previous contents in a closure as
the argument. All instances of recursion during parsing call through
either Parser::statement(), Parser::unary_expression(), or
Parser::type_decl(), so only these functions have been updated as
described in order to keep the patch as unobtrusive as possible.
A value of 256 has been chosen as the recursion limit, but can be
later tweaked if required. This avoids the stack overflow in the
testcase attached to issue #5757.
* fix(naga-spv-in): Image write value type is invalid.
* fix(naga-spv-in): input vector 4 may case error
* fix(naga-spv-in): Incorrect swizzle pattern for vector size 3.
In compaction, correctly identify unused types and global expressions,
rather than treating all global expressions referred to by
`PendingArraySize::Expression` array lengths as used even if the array
type itself is not.
This is tested by checking that going from expression to type and
back, along with the opposite, is correctly marked as used. It also
checks that adding an unused type using an expression gets compacted
out.
See the comments on `ModuleTracer::type_expression_tandem` for
details.
Fixes#6788.
Signed integer overflow is undefined behaviour in MSL. However, signed
integers are defined to be two's complement. This allows us to cast
signed values to their corresponding unsigned type, perform the
arithmetic on these unsigned values (which has defined overflow
behaviour) then cast the result back to signed.
Care must be taken when emitting the isign polyfill, which uses
metal::select(). We must ensure the -1, 0, and 1 literals used as
inputs to select() have the correct width, else bitcasting the output
of select() will fail due to mismatched widths.
* Initial Commit
* Remove now-redundant `format` import
* Update CHANGELOG.md
* Appropriately feature-gate `texture_format_serialize` test
* Remove `alloc` feature
Also fixed some documentation links and a Wasm `std` import
* Revert change to `Serialize` for `TextureFormat`
* Combine use statements
* Switch from `PathBuf` to `String`
* Consider environmental flags as unset on `no_std`
* Fix missing `format!`
* Add new CI tasks for `no_std` testing
* Comment out known failing CI matrix option
* Update all usage of `Dx12Compiler::DynamicDxc`
* Added comments to CI
* Update .github/workflows/ci.yml
* Update .github/workflows/ci.yml
* Update .github/workflows/ci.yml
* CI Touchups
---------
Co-authored-by: Connor Fitzgerald <connorwadefitzgerald@gmail.com>
