encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-20 18:29:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename constant::Constant to constant::Value.

Browse Source 
This CL renames constant::Constant to constant::Value as it reads a bit
nicer.

Bug: tint:1718
Change-Id: I3489a271ebe229dabf98e7668bdaef4fec375534
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/114361
Commit-Queue: Dan Sinclair <dsinclair@chromium.org>
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: Ben Clayton <bclayton@google.com>
This commit is contained in:
dan sinclair
2022-12-15 16:25:31 +00:00
committed by Dawn LUCI CQ
parent 7bacdfab4c
commit b53b8cf5be
46 changed files with 596 additions and 588 deletions
Download Patch File Download Diff File Expand all files Collapse all files

523
src/tint/resolver/const_eval.cc
View File

File diff suppressed because it is too large Load Diff

232
src/tint/resolver/const_eval.h
View File

@@ -31,7 +31,7 @@ namespace tint::ast {
class LiteralExpression;
} // namespace tint::ast
namespace tint::constant {
class Constant;
class Value;
} // namespace tint::constant
namespace tint::sem {
class Expression;
@@ -50,20 +50,20 @@ class ConstEval {
public:
/// The result type of a method that may raise a diagnostic error and the caller should abort
/// resolving. Can be one of three distinct values:
/// * A non-null constant::Constant pointer. Returned when a expression resolves to a creation
/// * A non-null constant::Value pointer. Returned when a expression resolves to a creation
/// time
/// value.
/// * A null constant::Constant pointer. Returned when a expression cannot resolve to a creation
/// * A null constant::Value pointer. Returned when a expression cannot resolve to a creation
/// time
/// value, but is otherwise legal.
/// * `utils::Failure`. Returned when there was a resolver error. In this situation the method
/// will have already reported a diagnostic error message, and the caller should abort
/// resolving.
using Result = utils::Result<const constant::Constant*>;
using Result = utils::Result<const constant::Value*>;
/// Typedef for a constant evaluation function
using Function = Result (ConstEval::*)(const type::Type* result_ty,
utils::VectorRef<const constant::Constant*>,
utils::VectorRef<const constant::Value*>,
const Source&);
/// Constructor
@@ -113,7 +113,7 @@ class ConstEval {
/// @param value the value being converted
/// @param source the source location
/// @return the converted value, or null if the value cannot be calculated
Result Convert(const type::Type* ty, const constant::Constant* value, const Source& source);
Result Convert(const type::Type* ty, const constant::Value* value, const Source& source);
////////////////////////////////////////////////////////////////////////////////////////////////
// Constant value evaluation methods, to be indirectly called via the intrinsic table
@@ -125,7 +125,7 @@ class ConstEval {
/// @param source the source location
/// @return the converted value, or null if the value cannot be calculated
Result Conv(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Zero value type initializer
@@ -134,7 +134,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result Zero(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Identity value type initializer
@@ -143,7 +143,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result Identity(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Vector splat initializer
@@ -152,7 +152,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result VecSplat(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Vector initializer using scalars
@@ -161,7 +161,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result VecInitS(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Vector initializer using a mix of scalars and smaller vectors
@@ -170,7 +170,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result VecInitM(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Matrix initializer using scalar values
@@ -179,7 +179,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result MatInitS(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Matrix initializer using column vectors
@@ -188,7 +188,7 @@ class ConstEval {
/// @param source the source location
/// @return the constructed value, or null if the value cannot be calculated
Result MatInitV(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
////////////////////////////////////////////////////////////////////////////
@@ -201,7 +201,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpComplement(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Unary minus operator '-'
@@ -210,7 +210,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpUnaryMinus(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Unary not operator '!'
@@ -219,7 +219,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpNot(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
////////////////////////////////////////////////////////////////////////////
@@ -232,7 +232,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpPlus(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Minus operator '-'
@@ -241,7 +241,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMinus(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Multiply operator '*' for the same type on the LHS and RHS
@@ -250,7 +250,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiply(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Multiply operator '*' for matCxR<T> * vecC<T>
@@ -259,7 +259,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiplyMatVec(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Multiply operator '*' for vecR<T> * matCxR<T>
@@ -268,7 +268,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiplyVecMat(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Multiply operator '*' for matKxR<T> * matCxK<T>
@@ -277,7 +277,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpMultiplyMatMat(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Divide operator '/'
@@ -286,7 +286,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpDivide(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Modulo operator '%'
@@ -295,7 +295,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpModulo(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Equality operator '=='
@@ -304,7 +304,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpEqual(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Inequality operator '!='
@@ -313,7 +313,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpNotEqual(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Less than operator '<'
@@ -322,7 +322,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLessThan(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Greater than operator '>'
@@ -331,7 +331,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpGreaterThan(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Less than or equal operator '<='
@@ -340,7 +340,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLessThanEqual(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Greater than or equal operator '>='
@@ -349,7 +349,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpGreaterThanEqual(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Logical and operator '&&'
@@ -358,7 +358,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLogicalAnd(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Logical or operator '||'
@@ -367,7 +367,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpLogicalOr(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Bitwise and operator '&'
@@ -376,7 +376,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpAnd(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Bitwise or operator '|'
@@ -385,7 +385,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpOr(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Bitwise xor operator '^'
@@ -394,7 +394,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpXor(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Bitwise shift left operator '<<'
@@ -403,7 +403,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpShiftLeft(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// Bitwise shift right operator '<<'
@@ -412,7 +412,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result OpShiftRight(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
////////////////////////////////////////////////////////////////////////////
@@ -425,7 +425,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result abs(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// acos builtin
@@ -434,7 +434,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result acos(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// acosh builtin
@@ -443,7 +443,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result acosh(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// all builtin
@@ -452,7 +452,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result all(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// any builtin
@@ -461,7 +461,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result any(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// asin builtin
@@ -470,7 +470,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result asin(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// asinh builtin
@@ -479,7 +479,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result asinh(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// atan builtin
@@ -488,7 +488,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result atan(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// atanh builtin
@@ -497,7 +497,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result atanh(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// atan2 builtin
@@ -506,7 +506,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result atan2(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// ceil builtin
@@ -515,7 +515,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result ceil(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// clamp builtin
@@ -524,7 +524,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result clamp(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// cos builtin
@@ -533,7 +533,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result cos(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// cosh builtin
@@ -542,7 +542,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result cosh(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// countLeadingZeros builtin
@@ -551,7 +551,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result countLeadingZeros(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// countOneBits builtin
@@ -560,7 +560,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result countOneBits(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// countTrailingZeros builtin
@@ -569,7 +569,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result countTrailingZeros(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// cross builtin
@@ -578,7 +578,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result cross(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// degrees builtin
@@ -587,7 +587,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result degrees(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// determinant builtin
@@ -596,7 +596,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result determinant(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// distance builtin
@@ -605,7 +605,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result distance(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// dot builtin
@@ -614,7 +614,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result dot(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// exp builtin
@@ -623,7 +623,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result exp(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// exp2 builtin
@@ -632,7 +632,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result exp2(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// extractBits builtin
@@ -641,7 +641,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result extractBits(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// faceForward builtin
@@ -650,7 +650,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result faceForward(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// firstLeadingBit builtin
@@ -659,7 +659,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result firstLeadingBit(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// firstTrailingBit builtin
@@ -668,7 +668,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result firstTrailingBit(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// floor builtin
@@ -677,7 +677,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result floor(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// fma builtin
@@ -686,7 +686,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result fma(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// fract builtin
@@ -695,7 +695,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result fract(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// frexp builtin
@@ -704,7 +704,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result frexp(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// insertBits builtin
@@ -713,7 +713,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result insertBits(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// inverseSqrt builtin
@@ -722,7 +722,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result inverseSqrt(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// length builtin
@@ -731,7 +731,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result length(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// log builtin
@@ -740,7 +740,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result log(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// log2 builtin
@@ -749,7 +749,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result log2(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// max builtin
@@ -758,7 +758,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result max(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// min builtin
@@ -767,7 +767,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result min(const type::Type* ty, // NOLINT(build/include_what_you_use) -- confused by min
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// mix builtin
@@ -776,7 +776,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result mix(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// modf builtin
@@ -785,7 +785,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result modf(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// normalize builtin
@@ -794,7 +794,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result normalize(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// pack2x16float builtin
@@ -803,7 +803,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack2x16float(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// pack2x16snorm builtin
@@ -812,7 +812,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack2x16snorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// pack2x16unorm builtin
@@ -821,7 +821,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack2x16unorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// pack4x8snorm builtin
@@ -830,7 +830,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack4x8snorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// pack4x8unorm builtin
@@ -839,7 +839,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pack4x8unorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// pow builtin
@@ -848,7 +848,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result pow(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// radians builtin
@@ -857,7 +857,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result radians(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// reflect builtin
@@ -866,7 +866,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result reflect(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// refract builtin
@@ -875,7 +875,7 @@ class ConstEval {
/// @param source the source location of the conversion
/// @return the result value, or null if the value cannot be calculated
Result refract(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// reverseBits builtin
@@ -884,7 +884,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result reverseBits(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// round builtin
@@ -893,7 +893,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result round(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// saturate builtin
@@ -902,7 +902,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result saturate(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// select builtin with single bool third arg
@@ -911,7 +911,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result select_bool(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// select builtin with vector of bool third arg
@@ -920,7 +920,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result select_boolvec(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// sign builtin
@@ -929,7 +929,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sign(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// sin builtin
@@ -938,7 +938,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sin(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// sinh builtin
@@ -947,7 +947,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sinh(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// smoothstep builtin
@@ -956,7 +956,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result smoothstep(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// step builtin
@@ -965,7 +965,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result step(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// sqrt builtin
@@ -974,7 +974,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result sqrt(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// tan builtin
@@ -983,7 +983,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result tan(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// tanh builtin
@@ -992,7 +992,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result tanh(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// transpose builtin
@@ -1001,7 +1001,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result transpose(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// trunc builtin
@@ -1010,7 +1010,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result trunc(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// unpack2x16float builtin
@@ -1019,7 +1019,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack2x16float(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// unpack2x16snorm builtin
@@ -1028,7 +1028,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack2x16snorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// unpack2x16unorm builtin
@@ -1037,7 +1037,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack2x16unorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// unpack4x8snorm builtin
@@ -1046,7 +1046,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack4x8snorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// unpack4x8unorm builtin
@@ -1055,7 +1055,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result unpack4x8unorm(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
/// quantizeToF16 builtin
@@ -1064,7 +1064,7 @@ class ConstEval {
/// @param source the source location
/// @return the result value, or null if the value cannot be calculated
Result quantizeToF16(const type::Type* ty,
utils::VectorRef<const constant::Constant*> args,
utils::VectorRef<const constant::Value*> args,
const Source& source);
private:
@@ -1361,14 +1361,14 @@ class ConstEval {
/// @param v1 the first vector
/// @param v2 the second vector
/// @returns the dot product
Result Dot(const Source& source, const constant::Constant* v1, const constant::Constant* v2);
Result Dot(const Source& source, const constant::Value* v1, const constant::Value* v2);
/// Returns the length of c0
/// @param source the source location
/// @param ty the return type
/// @param c0 the constant to calculate the length of
/// @returns the length of c0
Result Length(const Source& source, const type::Type* ty, const constant::Constant* c0);
Result Length(const Source& source, const type::Type* ty, const constant::Value* c0);
/// Returns the product of v1 and v2
/// @param source the source location
@@ -1378,8 +1378,8 @@ class ConstEval {
/// @returns the product of v1 and v2
Result Mul(const Source& source,
const type::Type* ty,
const constant::Constant* v1,
const constant::Constant* v2);
const constant::Value* v1,
const constant::Value* v2);
/// Returns the difference between v2 and v1
/// @param source the source location
@@ -1389,8 +1389,8 @@ class ConstEval {
/// @returns the difference between v2 and v1
Result Sub(const Source& source,
const type::Type* ty,
const constant::Constant* v1,
const constant::Constant* v2);
const constant::Value* v1,
const constant::Value* v2);
ProgramBuilder& builder;
};

15
src/tint/resolver/const_eval_binary_op_test.cc
View File

@@ -99,7 +99,7 @@ TEST_P(ResolverConstEvalBinaryOpTest, Test) {
auto& expected = expected_case.value;
auto* sem = Sem().Get(expr);
const constant::Constant* value = sem->ConstantValue();
const constant::Value* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());
@@ -892,20 +892,19 @@ TEST_F(ResolverConstEvalTest, NotAndOrOfVecs) {
EXPECT_TRUE(r()->Resolve()) << r()->error();
auto* sem = Sem().Get(expr);
const constant::Constant* value = sem->ConstantValue();
const constant::Value* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());
auto* expected_sem = Sem().Get(expected_expr);
const constant::Constant* expected_value = expected_sem->ConstantValue();
const constant::Value* expected_value = expected_sem->ConstantValue();
ASSERT_NE(expected_value, nullptr);
EXPECT_TYPE(expected_value->Type(), expected_sem->Type());
ForEachElemPair(value, expected_value,
[&](const constant::Constant* a, const constant::Constant* b) {
EXPECT_EQ(a->ValueAs<bool>(), b->ValueAs<bool>());
return HasFailure() ? Action::kStop : Action::kContinue;
});
ForEachElemPair(value, expected_value, [&](const constant::Value* a, const constant::Value* b) {
EXPECT_EQ(a->ValueAs<bool>(), b->ValueAs<bool>());
return HasFailure() ? Action::kStop : Action::kContinue;
});
}
template <typename T>

2
src/tint/resolver/const_eval_builtin_test.cc
View File

@@ -162,7 +162,7 @@ TEST_P(ResolverConstEvalBuiltinTest, Test) {
auto* sem = Sem().Get(expr);
ASSERT_NE(sem, nullptr);
const constant::Constant* value = sem->ConstantValue();
const constant::Value* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());

8
src/tint/resolver/const_eval_member_access_test.cc
View File

@@ -89,10 +89,10 @@ TEST_F(ResolverConstEvalTest, Matrix_AFloat_Construct_From_AInt_Vectors) {
EXPECT_FALSE(cv->AllZero());
auto* c0 = cv->Index(0);
auto* c1 = cv->Index(1);
EXPECT_EQ(std::get<AFloat>(c0->Index(0)->Value()), 1.0);
EXPECT_EQ(std::get<AFloat>(c0->Index(1)->Value()), 2.0);
EXPECT_EQ(std::get<AFloat>(c1->Index(0)->Value()), 3.0);
EXPECT_EQ(std::get<AFloat>(c1->Index(1)->Value()), 4.0);
EXPECT_EQ(c0->Index(0)->ValueAs<AFloat>(), 1.0);
EXPECT_EQ(c0->Index(1)->ValueAs<AFloat>(), 2.0);
EXPECT_EQ(c1->Index(0)->ValueAs<AFloat>(), 3.0);
EXPECT_EQ(c1->Index(1)->ValueAs<AFloat>(), 4.0);
}
} // namespace
} // namespace tint::resolver

13
src/tint/resolver/const_eval_test.h
View File

@@ -36,10 +36,9 @@ inline const auto kPiOver4 = T(UnwrapNumber<T>(0.785398163397448309616));
template <typename T>
inline const auto k3PiOver4 = T(UnwrapNumber<T>(2.356194490192344928846));
/// Walks the constant::Constant @p c, accumulating all the inner-most scalar values into @p args
/// Walks the constant::Value @p c, accumulating all the inner-most scalar values into @p args
template <size_t N>
inline void CollectScalars(const constant::Constant* c,
utils::Vector<builder::Scalar, N>& scalars) {
inline void CollectScalars(const constant::Value* c, utils::Vector<builder::Scalar, N>& scalars) {
Switch(
c->Type(), //
[&](const type::AbstractInt*) { scalars.Push(c->ValueAs<AInt>()); },
@@ -57,8 +56,8 @@ inline void CollectScalars(const constant::Constant* c,
});
}
/// Walks the constant::Constant @p c, returning all the inner-most scalar values.
inline utils::Vector<builder::Scalar, 16> ScalarsFrom(const constant::Constant* c) {
/// Walks the constant::Value @p c, returning all the inner-most scalar values.
inline utils::Vector<builder::Scalar, 16> ScalarsFrom(const constant::Value* c) {
utils::Vector<builder::Scalar, 16> out;
CollectScalars(c, out);
return out;
@@ -89,7 +88,7 @@ struct CheckConstantFlags {
/// @param got_constant the constant value evaluated by the resolver
/// @param expected_value the expected value for the test
/// @param flags optional flags for controlling the comparisons
inline void CheckConstant(const constant::Constant* got_constant,
inline void CheckConstant(const constant::Value* got_constant,
const builder::Value& expected_value,
CheckConstantFlags flags = {}) {
auto values_flat = ScalarsFrom(got_constant);
@@ -258,7 +257,7 @@ using builder::Vec;
// TODO(amaiorano): Move to Constant.h?
enum class Action { kStop, kContinue };
template <typename Func>
inline Action ForEachElemPair(const constant::Constant* a, const constant::Constant* b, Func&& f) {
inline Action ForEachElemPair(const constant::Value* a, const constant::Value* b, Func&& f) {
EXPECT_EQ(a->Type(), b->Type());
size_t i = 0;
while (true) {

2
src/tint/resolver/const_eval_unary_op_test.cc
View File

@@ -57,7 +57,7 @@ TEST_P(ResolverConstEvalUnaryOpTest, Test) {
ASSERT_TRUE(r()->Resolve()) << r()->error();
auto* sem = Sem().Get(expr);
const constant::Constant* value = sem->ConstantValue();
const constant::Value* value = sem->ConstantValue();
ASSERT_NE(value, nullptr);
EXPECT_TYPE(value->Type(), sem->Type());

8
src/tint/resolver/materialize_test.cc
View File

@@ -101,7 +101,7 @@ class MaterializeTest : public resolver::ResolverTestWithParam<CASE> {
auto* el = value->Index(i);
ASSERT_NE(el, nullptr);
EXPECT_TYPE(el->Type(), v->type());
EXPECT_EQ(std::get<T>(el->Value()), expected_value);
EXPECT_EQ(el->ValueAs<T>(), expected_value);
}
},
[&](const type::Matrix* m) {
@@ -113,7 +113,7 @@ class MaterializeTest : public resolver::ResolverTestWithParam<CASE> {
auto* el = column->Index(r);
ASSERT_NE(el, nullptr);
EXPECT_TYPE(el->Type(), m->type());
EXPECT_EQ(std::get<T>(el->Value()), expected_value);
EXPECT_EQ(el->ValueAs<T>(), expected_value);
}
}
},
@@ -124,10 +124,10 @@ class MaterializeTest : public resolver::ResolverTestWithParam<CASE> {
auto* el = value->Index(i);
ASSERT_NE(el, nullptr);
EXPECT_TYPE(el->Type(), a->ElemType());
EXPECT_EQ(std::get<T>(el->Value()), expected_value);
EXPECT_EQ(el->ValueAs<T>(), expected_value);
}
},
[&](Default) { EXPECT_EQ(std::get<T>(value->Value()), expected_value); });
[&](Default) { EXPECT_EQ(value->ValueAs<T>(), expected_value); });
}
};

24
src/tint/resolver/resolver.cc
View File

@@ -1278,7 +1278,7 @@ sem::CaseStatement* Resolver::CaseStatement(const ast::CaseStatement* stmt, cons
ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "case selector"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
const constant::Constant* const_value = nullptr;
const constant::Value* const_value = nullptr;
if (!sel->IsDefault()) {
// The sem statement was created in the switch when attempting to determine the
// common type.
@@ -1797,7 +1797,7 @@ const sem::Expression* Resolver::Materialize(const sem::Expression* expr,
return nullptr;
}
const constant::Constant* materialized_val = nullptr;
const constant::Value* materialized_val = nullptr;
if (!skip_const_eval_.Contains(decl)) {
auto expr_val = expr->ConstantValue();
if (!expr_val) {
@@ -1849,7 +1849,7 @@ bool Resolver::ShouldMaterializeArgument(const type::Type* parameter_ty) const {
return param_el_ty && !param_el_ty->Is<type::AbstractNumeric>();
}
bool Resolver::Convert(const constant::Constant*& c,
bool Resolver::Convert(const constant::Value*& c,
const type::Type* target_ty,
const Source& source) {
auto r = const_eval_.Convert(target_ty, c, source);
@@ -1861,7 +1861,7 @@ bool Resolver::Convert(const constant::Constant*& c,
}
template <size_t N>
utils::Result<utils::Vector<const constant::Constant*, N>> Resolver::ConvertArguments(
utils::Result<utils::Vector<const constant::Value*, N>> Resolver::ConvertArguments(
const utils::Vector<const sem::Expression*, N>& args,
const sem::CallTarget* target) {
auto const_args = utils::Transform(args, [](auto* arg) { return arg->ConstantValue(); });
@@ -1919,7 +1919,7 @@ sem::Expression* Resolver::IndexAccessor(const ast::IndexAccessorExpression* exp
ty = builder_->create<type::Reference>(ty, ref->AddressSpace(), ref->Access());
}
const constant::Constant* val = nullptr;
const constant::Value* val = nullptr;
auto stage = sem::EarliestStage(obj->Stage(), idx->Stage());
if (stage == sem::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = sem::EvaluationStage::kNotEvaluated;
@@ -1950,7 +1950,7 @@ sem::Expression* Resolver::Bitcast(const ast::BitcastExpression* expr) {
RegisterLoadIfNeeded(inner);
const constant::Constant* val = nullptr;
const constant::Value* val = nullptr;
// TODO(crbug.com/tint/1582): short circuit 'expr' once const eval of Bitcast is implemented.
if (auto r = const_eval_.Bitcast(ty, inner)) {
val = r.Get();
@@ -2012,7 +2012,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
return nullptr;
}
const constant::Constant* value = nullptr;
const constant::Value* value = nullptr;
auto stage = sem::EarliestStage(ctor_or_conv.target->Stage(), args_stage);
if (stage == sem::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = sem::EvaluationStage::kNotEvaluated;
@@ -2042,7 +2042,7 @@ sem::Call* Resolver::Call(const ast::CallExpression* expr) {
}
auto stage = args_stage; // The evaluation stage of the call
const constant::Constant* value = nullptr; // The constant value for the call
const constant::Value* value = nullptr; // The constant value for the call
if (stage == sem::EvaluationStage::kConstant) {
if (auto r = const_eval_.ArrayOrStructInit(ty, args)) {
value = r.Get();
@@ -2336,7 +2336,7 @@ sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr,
// If the builtin is @const, and all arguments have constant values, evaluate the builtin
// now.
const constant::Constant* value = nullptr;
const constant::Value* value = nullptr;
auto stage = sem::EarliestStage(arg_stage, builtin.sem->Stage());
if (stage == sem::EvaluationStage::kConstant && skip_const_eval_.Contains(expr)) {
stage = sem::EvaluationStage::kNotEvaluated;
@@ -2607,7 +2607,7 @@ sem::Expression* Resolver::Literal(const ast::LiteralExpression* literal) {
return nullptr;
}
const constant::Constant* val = nullptr;
const constant::Value* val = nullptr;
if (auto r = const_eval_.Literal(ty, literal)) {
val = r.Get();
} else {
@@ -2875,7 +2875,7 @@ sem::Expression* Resolver::Binary(const ast::BinaryExpression* expr) {
RegisterLoadIfNeeded(lhs);
RegisterLoadIfNeeded(rhs);
const constant::Constant* value = nullptr;
const constant::Value* value = nullptr;
if (stage == sem::EvaluationStage::kConstant) {
if (op.const_eval_fn) {
if (skip_const_eval_.Contains(expr)) {
@@ -2920,7 +2920,7 @@ sem::Expression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) {
const type::Type* ty = nullptr;
const sem::Variable* root_ident = nullptr;
const constant::Constant* value = nullptr;
const constant::Value* value = nullptr;
auto stage = sem::EvaluationStage::kRuntime;
switch (unary->op) {

6
src/tint/resolver/resolver.h
View File

@@ -23,7 +23,7 @@
#include <utility>
#include <vector>
#include "src/tint/constant/constant.h"
#include "src/tint/constant/value.h"
#include "src/tint/program_builder.h"
#include "src/tint/resolver/const_eval.h"
#include "src/tint/resolver/dependency_graph.h"
@@ -197,13 +197,13 @@ class Resolver {
/// Converts `c` to `target_ty`
/// @returns true on success, false on failure.
bool Convert(const constant::Constant*& c, const type::Type* target_ty, const Source& source);
bool Convert(const constant::Value*& c, const type::Type* target_ty, const Source& source);
/// Transforms `args` to a vector of constants, and converts each constant to the call target's
/// parameter type.
/// @returns the vector of constants, `utils::Failure` on failure.
template <size_t N>
utils::Result<utils::Vector<const constant::Constant*, N>> ConvertArguments(
utils::Result<utils::Vector<const constant::Value*, N>> ConvertArguments(
const utils::Vector<const sem::Expression*, N>& args,
const sem::CallTarget* target);