tint/sem: Rename Expression to ValueExpression
ast::IdentifierExpression may also resolve to a type or core enumerator
Bug: tint:1810
Change-Id: I85e3bea67e1146215079ec47430784f2fb39043d
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/118402
Kokoro: Kokoro <noreply+kokoro@google.com>
Reviewed-by: James Price <jrprice@google.com>
Commit-Queue: Ben Clayton <bclayton@google.com>
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index 7b114ea..066d656 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -367,7 +367,6 @@
"sem/call.h",
"sem/call_target.h",
"sem/evaluation_stage.h",
- "sem/expression.h",
"sem/for_loop_statement.h",
"sem/function.h",
"sem/if_statement.h",
@@ -388,6 +387,7 @@
"sem/type_conversion.h",
"sem/type_initializer.h",
"sem/type_mappings.h",
+ "sem/value_expression.h",
"sem/variable.h",
"sem/while_statement.h",
]
@@ -760,8 +760,6 @@
"sem/call_target.cc",
"sem/call_target.h",
"sem/evaluation_stage.h",
- "sem/expression.cc",
- "sem/expression.h",
"sem/for_loop_statement.cc",
"sem/for_loop_statement.h",
"sem/function.cc",
@@ -799,6 +797,8 @@
"sem/type_initializer.cc",
"sem/type_initializer.h",
"sem/type_mappings.h",
+ "sem/value_expression.cc",
+ "sem/value_expression.h",
"sem/variable.cc",
"sem/variable.h",
"sem/while_statement.cc",
@@ -1484,8 +1484,8 @@
sources = [
"sem/builtin_test.cc",
"sem/diagnostic_severity_test.cc",
- "sem/expression_test.cc",
"sem/struct_test.cc",
+ "sem/value_expression_test.cc",
]
}
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index 2c8d022..dfd33ee 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -328,8 +328,6 @@
sem/call.cc
sem/call.h
sem/evaluation_stage.h
- sem/expression.cc
- sem/expression.h
sem/for_loop_statement.cc
sem/for_loop_statement.h
sem/function.cc
@@ -363,6 +361,8 @@
sem/type_conversion.h
sem/type_mappings.h
sem/variable.cc
+ sem/value_expression.cc
+ sem/value_expression.h
sem/while_statement.cc
sem/while_statement.h
symbol_table.cc
@@ -972,8 +972,8 @@
scope_stack_test.cc
sem/builtin_test.cc
sem/diagnostic_severity_test.cc
- sem/expression_test.cc
sem/struct_test.cc
+ sem/value_expression_test.cc
source_test.cc
symbol_table_test.cc
symbol_test.cc
diff --git a/src/tint/ast/expression.cc b/src/tint/ast/expression.cc
index 17b3dc2..8eacff1 100644
--- a/src/tint/ast/expression.cc
+++ b/src/tint/ast/expression.cc
@@ -14,8 +14,8 @@
#include "src/tint/ast/expression.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/info.h"
+#include "src/tint/sem/value_expression.h"
TINT_INSTANTIATE_TYPEINFO(tint::ast::Expression);
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/delete_statements.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/delete_statements.cc
index f1d7e4d..90c0820 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/delete_statements.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/delete_statements.cc
@@ -19,8 +19,8 @@
#include "src/tint/fuzzers/tint_ast_fuzzer/jump_tracker.h"
#include "src/tint/fuzzers/tint_ast_fuzzer/mutations/delete_statement.h"
#include "src/tint/fuzzers/tint_ast_fuzzer/util.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/variable.h"
namespace tint::fuzzers::ast_fuzzer {
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/replace_identifiers.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/replace_identifiers.cc
index 8146aa4..7560cf7 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/replace_identifiers.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/replace_identifiers.cc
@@ -19,8 +19,8 @@
#include "src/tint/fuzzers/tint_ast_fuzzer/mutations/replace_identifier.h"
#include "src/tint/fuzzers/tint_ast_fuzzer/util.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/variable.h"
namespace tint::fuzzers::ast_fuzzer {
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/wrap_unary_operators.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/wrap_unary_operators.cc
index 12fe82c..11c8cd6 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/wrap_unary_operators.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutation_finders/wrap_unary_operators.cc
@@ -20,8 +20,8 @@
#include "src/tint/fuzzers/tint_ast_fuzzer/expression_size.h"
#include "src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.h"
#include "src/tint/fuzzers/tint_ast_fuzzer/util.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
namespace tint::fuzzers::ast_fuzzer {
@@ -51,7 +51,7 @@
continue;
}
- const auto* expr_sem_node = tint::As<sem::Expression>(program.Sem().Get(expr_ast_node));
+ const auto* expr_sem_node = program.Sem().Get<sem::ValueExpression>(expr_ast_node);
// Transformation applies only when the semantic node for the given
// expression is present.
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.cc b/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.cc
index 3420e45..9d65d78 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.cc
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.cc
@@ -50,8 +50,7 @@
return false;
}
- const auto* expression_sem_node =
- tint::As<sem::Expression>(program.Sem().Get(expression_ast_node));
+ const auto* expression_sem_node = program.Sem().Get<sem::ValueExpression>(expression_ast_node);
if (!expression_sem_node) {
// Semantic information for the expression ast node is not present
@@ -94,7 +93,7 @@
}
std::vector<ast::UnaryOp> MutationWrapUnaryOperator::GetValidUnaryWrapper(
- const sem::Expression& expr) {
+ const sem::ValueExpression& expr) {
const auto* expr_type = expr.Type();
if (expr_type->is_bool_scalar_or_vector()) {
return {ast::UnaryOp::kNot};
diff --git a/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.h b/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.h
index 96d0926..0ca6213 100644
--- a/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.h
+++ b/src/tint/fuzzers/tint_ast_fuzzer/mutations/wrap_unary_operator.h
@@ -68,7 +68,7 @@
/// expression.
/// @param expr - an `ast::Expression` instance from node id map.
/// @return a list of unary operators.
- static std::vector<ast::UnaryOp> GetValidUnaryWrapper(const sem::Expression& expr);
+ static std::vector<ast::UnaryOp> GetValidUnaryWrapper(const sem::ValueExpression& expr);
private:
protobufs::MutationWrapUnaryOperator message_;
diff --git a/src/tint/ir/builder_impl.cc b/src/tint/ir/builder_impl.cc
index 2a8ed06e..cde71e2 100644
--- a/src/tint/ir/builder_impl.cc
+++ b/src/tint/ir/builder_impl.cc
@@ -47,9 +47,9 @@
#include "src/tint/ir/switch.h"
#include "src/tint/ir/terminator.h"
#include "src/tint/program.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/module.h"
#include "src/tint/sem/switch_statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/type/void.h"
namespace tint::ir {
diff --git a/src/tint/program.cc b/src/tint/program.cc
index 5003caa..f2a766a 100644
--- a/src/tint/program.cc
+++ b/src/tint/program.cc
@@ -18,7 +18,7 @@
#include "src/tint/demangler.h"
#include "src/tint/resolver/resolver.h"
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
namespace tint {
namespace {
diff --git a/src/tint/program_builder.cc b/src/tint/program_builder.cc
index 9b9e1d2..1a0faf6 100644
--- a/src/tint/program_builder.cc
+++ b/src/tint/program_builder.cc
@@ -19,7 +19,7 @@
#include "src/tint/ast/variable_decl_statement.h"
#include "src/tint/debug.h"
#include "src/tint/demangler.h"
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/variable.h"
#include "src/tint/utils/compiler_macros.h"
diff --git a/src/tint/resolver/const_eval.cc b/src/tint/resolver/const_eval.cc
index 9164276..0517629 100644
--- a/src/tint/resolver/const_eval.cc
+++ b/src/tint/resolver/const_eval.cc
@@ -1165,7 +1165,7 @@
}
ConstEval::Result ConstEval::ArrayOrStructInit(const type::Type* ty,
- utils::VectorRef<const sem::Expression*> args) {
+ utils::VectorRef<const sem::ValueExpression*> args) {
if (args.IsEmpty()) {
return ZeroValue(builder, ty);
}
@@ -1277,8 +1277,8 @@
return builder.create<constant::Composite>(ty, args);
}
-ConstEval::Result ConstEval::Index(const sem::Expression* obj_expr,
- const sem::Expression* idx_expr) {
+ConstEval::Result ConstEval::Index(const sem::ValueExpression* obj_expr,
+ const sem::ValueExpression* idx_expr) {
auto idx_val = idx_expr->ConstantValue();
if (!idx_val) {
return nullptr;
@@ -1306,7 +1306,7 @@
return obj_val->Index(static_cast<size_t>(idx));
}
-ConstEval::Result ConstEval::MemberAccess(const sem::Expression* obj_expr,
+ConstEval::Result ConstEval::MemberAccess(const sem::ValueExpression* obj_expr,
const type::StructMember* member) {
auto obj_val = obj_expr->ConstantValue();
if (!obj_val) {
@@ -1316,7 +1316,7 @@
}
ConstEval::Result ConstEval::Swizzle(const type::Type* ty,
- const sem::Expression* vec_expr,
+ const sem::ValueExpression* vec_expr,
utils::VectorRef<uint32_t> indices) {
auto* vec_val = vec_expr->ConstantValue();
if (!vec_val) {
diff --git a/src/tint/resolver/const_eval.h b/src/tint/resolver/const_eval.h
index dbb1c2e..6c26511 100644
--- a/src/tint/resolver/const_eval.h
+++ b/src/tint/resolver/const_eval.h
@@ -34,7 +34,7 @@
class Value;
} // namespace tint::constant
namespace tint::sem {
-class Expression;
+class ValueExpression;
} // namespace tint::sem
namespace tint::type {
class StructMember;
@@ -77,7 +77,8 @@
/// @param ty the target type - must be an array or initializer
/// @param args the input arguments
/// @return the constructed value, or null if the value cannot be calculated
- Result ArrayOrStructInit(const type::Type* ty, utils::VectorRef<const sem::Expression*> args);
+ Result ArrayOrStructInit(const type::Type* ty,
+ utils::VectorRef<const sem::ValueExpression*> args);
/// @param ty the target type
/// @param value the value being converted
@@ -89,7 +90,7 @@
/// @param obj the object being indexed
/// @param idx the index expression
/// @return the result of the index, or null if the value cannot be calculated
- Result Index(const sem::Expression* obj, const sem::Expression* idx);
+ Result Index(const sem::ValueExpression* obj, const sem::ValueExpression* idx);
/// @param ty the result type
/// @param lit the literal AST node
@@ -99,14 +100,14 @@
/// @param obj the object being accessed
/// @param member the member
/// @return the result of the member access, or null if the value cannot be calculated
- Result MemberAccess(const sem::Expression* obj, const type::StructMember* member);
+ Result MemberAccess(const sem::ValueExpression* obj, const type::StructMember* member);
/// @param ty the result type
/// @param vector the vector being swizzled
/// @param indices the swizzle indices
/// @return the result of the swizzle, or null if the value cannot be calculated
Result Swizzle(const type::Type* ty,
- const sem::Expression* vector,
+ const sem::ValueExpression* vector,
utils::VectorRef<uint32_t> indices);
/// Convert the `value` to `target_type`
diff --git a/src/tint/resolver/materialize_test.cc b/src/tint/resolver/materialize_test.cc
index 274244d..e34e999 100644
--- a/src/tint/resolver/materialize_test.cc
+++ b/src/tint/resolver/materialize_test.cc
@@ -76,7 +76,7 @@
protected:
using ProgramBuilder::FriendlyName;
- void CheckTypesAndValues(const sem::Expression* expr,
+ void CheckTypesAndValues(const sem::ValueExpression* expr,
const tint::type::Type* expected_sem_ty,
const std::variant<AInt, AFloat>& expected_value) {
std::visit([&](auto v) { CheckTypesAndValuesImpl(expr, expected_sem_ty, v); },
@@ -85,7 +85,7 @@
private:
template <typename T>
- void CheckTypesAndValuesImpl(const sem::Expression* expr,
+ void CheckTypesAndValuesImpl(const sem::ValueExpression* expr,
const tint::type::Type* expected_sem_ty,
T expected_value) {
EXPECT_TYPE(expr->Type(), expected_sem_ty);
diff --git a/src/tint/resolver/resolver.cc b/src/tint/resolver/resolver.cc
index de616b9..3bccfe8 100644
--- a/src/tint/resolver/resolver.cc
+++ b/src/tint/resolver/resolver.cc
@@ -453,7 +453,7 @@
}
}
- const sem::Expression* rhs = nullptr;
+ const sem::ValueExpression* rhs = nullptr;
// Does the variable have an initializer?
if (v->initializer) {
@@ -545,7 +545,7 @@
return nullptr;
}
- const sem::Expression* rhs = nullptr;
+ const sem::ValueExpression* rhs = nullptr;
{
ExprEvalStageConstraint constraint{sem::EvaluationStage::kConstant, "const initializer"};
TINT_SCOPED_ASSIGNMENT(expr_eval_stage_constraint_, constraint);
@@ -603,7 +603,7 @@
}
}
- const sem::Expression* rhs = nullptr;
+ const sem::ValueExpression* rhs = nullptr;
// Does the variable have a initializer?
if (var->initializer) {
@@ -1164,7 +1164,7 @@
}
auto values = attr->Values();
- utils::Vector<const sem::Expression*, 3> args;
+ utils::Vector<const sem::ValueExpression*, 3> args;
utils::Vector<const type::Type*, 3> arg_tys;
constexpr const char* kErrBadExpr =
@@ -1515,7 +1515,7 @@
});
}
-sem::Expression* Resolver::Expression(const ast::Expression* root) {
+sem::ValueExpression* Resolver::Expression(const ast::Expression* root) {
utils::Vector<const ast::Expression*, 64> sorted;
constexpr size_t kMaxExpressionDepth = 512U;
bool failed = false;
@@ -1550,30 +1550,34 @@
for (auto* expr : utils::Reverse(sorted)) {
auto* sem_expr = Switch(
expr,
- [&](const ast::IndexAccessorExpression* array) -> sem::Expression* {
+ [&](const ast::IndexAccessorExpression* array) -> sem::ValueExpression* {
return IndexAccessor(array);
},
- [&](const ast::BinaryExpression* bin_op) -> sem::Expression* { return Binary(bin_op); },
- [&](const ast::BitcastExpression* bitcast) -> sem::Expression* {
+ [&](const ast::BinaryExpression* bin_op) -> sem::ValueExpression* {
+ return Binary(bin_op);
+ },
+ [&](const ast::BitcastExpression* bitcast) -> sem::ValueExpression* {
return Bitcast(bitcast);
},
- [&](const ast::CallExpression* call) -> sem::Expression* { return Call(call); },
- [&](const ast::IdentifierExpression* ident) -> sem::Expression* {
+ [&](const ast::CallExpression* call) -> sem::ValueExpression* { return Call(call); },
+ [&](const ast::IdentifierExpression* ident) -> sem::ValueExpression* {
return Identifier(ident);
},
- [&](const ast::LiteralExpression* literal) -> sem::Expression* {
+ [&](const ast::LiteralExpression* literal) -> sem::ValueExpression* {
return Literal(literal);
},
- [&](const ast::MemberAccessorExpression* member) -> sem::Expression* {
+ [&](const ast::MemberAccessorExpression* member) -> sem::ValueExpression* {
return MemberAccessor(member);
},
- [&](const ast::UnaryOpExpression* unary) -> sem::Expression* { return UnaryOp(unary); },
- [&](const ast::PhonyExpression*) -> sem::Expression* {
- return builder_->create<sem::Expression>(expr, builder_->create<type::Void>(),
- sem::EvaluationStage::kRuntime,
- current_statement_,
- /* constant_value */ nullptr,
- /* has_side_effects */ false);
+ [&](const ast::UnaryOpExpression* unary) -> sem::ValueExpression* {
+ return UnaryOp(unary);
+ },
+ [&](const ast::PhonyExpression*) -> sem::ValueExpression* {
+ return builder_->create<sem::ValueExpression>(expr, builder_->create<type::Void>(),
+ sem::EvaluationStage::kRuntime,
+ current_statement_,
+ /* constant_value */ nullptr,
+ /* has_side_effects */ false);
},
[&](Default) {
TINT_ICE(Resolver, diagnostics_)
@@ -1621,7 +1625,7 @@
return nullptr;
}
-void Resolver::RegisterStore(const sem::Expression* expr) {
+void Resolver::RegisterStore(const sem::ValueExpression* expr) {
auto& info = alias_analysis_infos_[current_function_];
Switch(
expr->RootIdentifier(),
@@ -1643,11 +1647,11 @@
// Helper to generate an aliasing error diagnostic.
struct Alias {
- const sem::Expression* expr; // the "other expression"
+ const sem::ValueExpression* expr; // the "other expression"
enum { Argument, ModuleScope } type; // the type of the "other" expression
std::string access; // the access performed for the "other" expression
};
- auto make_error = [&](const sem::Expression* arg, Alias&& var) {
+ auto make_error = [&](const sem::ValueExpression* arg, Alias&& var) {
// TODO(crbug.com/tint/1675): Switch to error and return false after deprecation period.
AddWarning("invalid aliased pointer argument", arg->Declaration()->source);
switch (var.type) {
@@ -1672,8 +1676,8 @@
auto& caller_info = alias_analysis_infos_[current_function_];
// Track the set of root identifiers that are read and written by arguments passed in this call.
- std::unordered_map<const sem::Variable*, const sem::Expression*> arg_reads;
- std::unordered_map<const sem::Variable*, const sem::Expression*> arg_writes;
+ std::unordered_map<const sem::Variable*, const sem::ValueExpression*> arg_reads;
+ std::unordered_map<const sem::Variable*, const sem::ValueExpression*> arg_writes;
for (size_t i = 0; i < args.Length(); i++) {
auto* arg = args[i];
if (!arg->Type()->Is<type::Pointer>()) {
@@ -1787,7 +1791,7 @@
});
}
-const sem::Expression* Resolver::Load(const sem::Expression* expr) {
+const sem::ValueExpression* Resolver::Load(const sem::ValueExpression* expr) {
if (!expr) {
// Allow for Load(Expression(blah)), where failures pass through Load()
return nullptr;
@@ -1814,8 +1818,8 @@
return load;
}
-const sem::Expression* Resolver::Materialize(const sem::Expression* expr,
- const type::Type* target_type /* = nullptr */) {
+const sem::ValueExpression* Resolver::Materialize(const sem::ValueExpression* expr,
+ const type::Type* target_type /* = nullptr */) {
if (!expr) {
// Allow for Materialize(Expression(blah)), where failures pass through Materialize()
return nullptr;
@@ -1865,7 +1869,7 @@
}
template <size_t N>
-bool Resolver::MaybeMaterializeAndLoadArguments(utils::Vector<const sem::Expression*, N>& args,
+bool Resolver::MaybeMaterializeAndLoadArguments(utils::Vector<const sem::ValueExpression*, N>& args,
const sem::CallTarget* target) {
for (size_t i = 0, n = std::min(args.Length(), target->Parameters().Length()); i < n; i++) {
const auto* param_ty = target->Parameters()[i]->Type();
@@ -1905,7 +1909,7 @@
template <size_t N>
utils::Result<utils::Vector<const constant::Value*, N>> Resolver::ConvertArguments(
- const utils::Vector<const sem::Expression*, N>& args,
+ const utils::Vector<const sem::ValueExpression*, N>& args,
const sem::CallTarget* target) {
auto const_args = utils::Transform(args, [](auto* arg) { return arg->ConstantValue(); });
for (size_t i = 0, n = std::min(args.Length(), target->Parameters().Length()); i < n; i++) {
@@ -1917,7 +1921,7 @@
return const_args;
}
-sem::Expression* Resolver::IndexAccessor(const ast::IndexAccessorExpression* expr) {
+sem::ValueExpression* Resolver::IndexAccessor(const ast::IndexAccessorExpression* expr) {
auto* idx = Load(Materialize(sem_.Get(expr->index)));
if (!idx) {
return nullptr;
@@ -1980,7 +1984,7 @@
return sem;
}
-sem::Expression* Resolver::Bitcast(const ast::BitcastExpression* expr) {
+sem::ValueExpression* Resolver::Bitcast(const ast::BitcastExpression* expr) {
auto* inner = Load(Materialize(sem_.Get(expr->expr)));
if (!inner) {
return nullptr;
@@ -2007,8 +2011,8 @@
}
}
- auto* sem = builder_->create<sem::Expression>(expr, ty, stage, current_statement_,
- std::move(value), inner->HasSideEffects());
+ auto* sem = builder_->create<sem::ValueExpression>(expr, ty, stage, current_statement_,
+ std::move(value), inner->HasSideEffects());
sem->Behaviors() = inner->Behaviors();
return sem;
}
@@ -2021,7 +2025,7 @@
// * A type conversion.
// Resolve all of the arguments, their types and the set of behaviors.
- utils::Vector<const sem::Expression*, 8> args;
+ utils::Vector<const sem::ValueExpression*, 8> args;
args.Reserve(expr->args.Length());
auto args_stage = sem::EvaluationStage::kConstant;
sem::Behaviors arg_behaviors;
@@ -2094,8 +2098,8 @@
// Constant evaluation failed.
// Can happen for expressions that will fail validation (later).
// Use the kRuntime EvaluationStage, as kConstant will trigger an assertion in
- // the sem::Expression initializer, which checks that kConstant is paired with a
- // constant value.
+ // the sem::ValueExpression initializer, which checks that kConstant is paired with
+ // a constant value.
stage = sem::EvaluationStage::kRuntime;
}
}
@@ -2344,7 +2348,7 @@
template <size_t N>
sem::Call* Resolver::BuiltinCall(const ast::CallExpression* expr,
sem::BuiltinType builtin_type,
- utils::Vector<const sem::Expression*, N>& args) {
+ utils::Vector<const sem::ValueExpression*, N>& args) {
auto arg_stage = sem::EvaluationStage::kConstant;
for (auto* arg : args) {
arg_stage = sem::EarliestStage(arg_stage, arg->Stage());
@@ -2515,8 +2519,9 @@
return nullptr;
}
-void Resolver::CollectTextureSamplerPairs(const sem::Builtin* builtin,
- utils::VectorRef<const sem::Expression*> args) const {
+void Resolver::CollectTextureSamplerPairs(
+ const sem::Builtin* builtin,
+ utils::VectorRef<const sem::ValueExpression*> args) const {
// Collect a texture/sampler pair for this builtin.
const auto& signature = builtin->Signature();
int texture_index = signature.IndexOf(sem::ParameterUsage::kTexture);
@@ -2542,7 +2547,7 @@
template <size_t N>
sem::Call* Resolver::FunctionCall(const ast::CallExpression* expr,
sem::Function* target,
- utils::Vector<const sem::Expression*, N>& args,
+ utils::Vector<const sem::ValueExpression*, N>& args,
sem::Behaviors arg_behaviors) {
auto sym = expr->target.name->symbol;
auto name = builder_->Symbols().NameFor(sym);
@@ -2592,8 +2597,9 @@
return call;
}
-void Resolver::CollectTextureSamplerPairs(sem::Function* func,
- utils::VectorRef<const sem::Expression*> args) const {
+void Resolver::CollectTextureSamplerPairs(
+ sem::Function* func,
+ utils::VectorRef<const sem::ValueExpression*> args) const {
// Map all texture/sampler pairs from the target function to the
// current function. These can only be global or parameter
// variables. Resolve any parameter variables to the corresponding
@@ -2615,7 +2621,7 @@
}
}
-sem::Expression* Resolver::Literal(const ast::LiteralExpression* literal) {
+sem::ValueExpression* Resolver::Literal(const ast::LiteralExpression* literal) {
auto* ty = Switch(
literal,
[&](const ast::IntLiteralExpression* i) -> type::Type* {
@@ -2669,11 +2675,12 @@
return nullptr;
}
}
- return builder_->create<sem::Expression>(literal, ty, stage, current_statement_, std::move(val),
- /* has_side_effects */ false);
+ return builder_->create<sem::ValueExpression>(literal, ty, stage, current_statement_,
+ std::move(val),
+ /* has_side_effects */ false);
}
-sem::Expression* Resolver::Identifier(const ast::IdentifierExpression* expr) {
+sem::ValueExpression* Resolver::Identifier(const ast::IdentifierExpression* expr) {
Mark(expr->identifier);
auto symbol = expr->identifier->symbol;
auto* sem_resolved = sem_.ResolvedSymbol<sem::Node>(expr);
@@ -2769,7 +2776,7 @@
return nullptr;
}
-sem::Expression* Resolver::MemberAccessor(const ast::MemberAccessorExpression* expr) {
+sem::ValueExpression* Resolver::MemberAccessor(const ast::MemberAccessorExpression* expr) {
auto* structure = sem_.TypeOf(expr->structure);
auto* storage_ty = structure->UnwrapRef();
auto* object = sem_.Get(expr->structure);
@@ -2784,7 +2791,7 @@
return Switch(
storage_ty, //
- [&](const sem::Struct* str) -> sem::Expression* {
+ [&](const sem::Struct* str) -> sem::ValueExpression* {
auto symbol = expr->member->symbol;
const sem::StructMember* member = nullptr;
@@ -2817,7 +2824,7 @@
has_side_effects, root_ident);
},
- [&](const type::Vector* vec) -> sem::Expression* {
+ [&](const type::Vector* vec) -> sem::ValueExpression* {
std::string s = builder_->Symbols().NameFor(expr->member->symbol);
auto size = s.size();
utils::Vector<uint32_t, 4> swizzle;
@@ -2868,7 +2875,7 @@
return nullptr;
}
- const sem::Expression* obj_expr = object;
+ const sem::ValueExpression* obj_expr = object;
if (size == 1) {
// A single element swizzle is just the type of the vector.
ty = vec->type();
@@ -2900,7 +2907,7 @@
});
}
-sem::Expression* Resolver::Binary(const ast::BinaryExpression* expr) {
+sem::ValueExpression* Resolver::Binary(const ast::BinaryExpression* expr) {
const auto* lhs = sem_.Get(expr->lhs);
const auto* rhs = sem_.Get(expr->rhs);
auto* lhs_ty = lhs->Type()->UnwrapRef();
@@ -2970,14 +2977,14 @@
}
bool has_side_effects = lhs->HasSideEffects() || rhs->HasSideEffects();
- auto* sem = builder_->create<sem::Expression>(expr, op.result, stage, current_statement_, value,
- has_side_effects);
+ auto* sem = builder_->create<sem::ValueExpression>(expr, op.result, stage, current_statement_,
+ value, has_side_effects);
sem->Behaviors() = lhs->Behaviors() + rhs->Behaviors();
return sem;
}
-sem::Expression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) {
+sem::ValueExpression* Resolver::UnaryOp(const ast::UnaryOpExpression* unary) {
const auto* expr = sem_.Get(unary->expr);
auto* expr_ty = expr->Type();
if (!expr_ty) {
@@ -3066,8 +3073,8 @@
}
}
- auto* sem = builder_->create<sem::Expression>(unary, ty, stage, current_statement_, value,
- expr->HasSideEffects(), root_ident);
+ auto* sem = builder_->create<sem::ValueExpression>(unary, ty, stage, current_statement_, value,
+ expr->HasSideEffects(), root_ident);
sem->Behaviors() = expr->Behaviors();
return sem;
}
diff --git a/src/tint/resolver/resolver.h b/src/tint/resolver/resolver.h
index 8c58626..b2cddf4 100644
--- a/src/tint/resolver/resolver.h
+++ b/src/tint/resolver/resolver.h
@@ -126,7 +126,7 @@
/// list (leaf-first) of all the expression nodes. Each of the expressions are then resolved by
/// dispatching to the appropriate expression handlers below.
/// @returns the resolved semantic node for the expression `expr`, or nullptr on failure.
- sem::Expression* Expression(const ast::Expression* expr);
+ sem::ValueExpression* Expression(const ast::Expression* expr);
////////////////////////////////////////////////////////////////////////////////////////////////
// Expression resolving methods
@@ -137,28 +137,28 @@
// not attempt to resolve their children. This design avoids recursion, which is a common cause
// of stack-overflows.
////////////////////////////////////////////////////////////////////////////////////////////////
- sem::Expression* IndexAccessor(const ast::IndexAccessorExpression*);
- sem::Expression* Binary(const ast::BinaryExpression*);
- sem::Expression* Bitcast(const ast::BitcastExpression*);
+ sem::ValueExpression* IndexAccessor(const ast::IndexAccessorExpression*);
+ sem::ValueExpression* Binary(const ast::BinaryExpression*);
+ sem::ValueExpression* Bitcast(const ast::BitcastExpression*);
sem::Call* Call(const ast::CallExpression*);
sem::Function* Function(const ast::Function*);
template <size_t N>
sem::Call* FunctionCall(const ast::CallExpression*,
sem::Function* target,
- utils::Vector<const sem::Expression*, N>& args,
+ utils::Vector<const sem::ValueExpression*, N>& args,
sem::Behaviors arg_behaviors);
- sem::Expression* Identifier(const ast::IdentifierExpression*);
+ sem::ValueExpression* Identifier(const ast::IdentifierExpression*);
template <size_t N>
sem::Call* BuiltinCall(const ast::CallExpression*,
sem::BuiltinType,
- utils::Vector<const sem::Expression*, N>& args);
- sem::Expression* Literal(const ast::LiteralExpression*);
- sem::Expression* MemberAccessor(const ast::MemberAccessorExpression*);
- sem::Expression* UnaryOp(const ast::UnaryOpExpression*);
+ utils::Vector<const sem::ValueExpression*, N>& args);
+ sem::ValueExpression* Literal(const ast::LiteralExpression*);
+ sem::ValueExpression* MemberAccessor(const ast::MemberAccessorExpression*);
+ sem::ValueExpression* UnaryOp(const ast::UnaryOpExpression*);
/// Register a memory store to an expression, to track accesses to root identifiers in order to
/// perform alias analysis.
- void RegisterStore(const sem::Expression* expr);
+ void RegisterStore(const sem::ValueExpression* expr);
/// Perform pointer alias analysis for `call`.
/// @returns true is the call arguments are free from aliasing issues, false otherwise.
@@ -166,7 +166,7 @@
/// If `expr` is of a reference type, then Load will create and return a sem::Load node wrapping
/// `expr`. If `expr` is not of a reference type, then Load will just return `expr`.
- const sem::Expression* Load(const sem::Expression* expr);
+ const sem::ValueExpression* Load(const sem::ValueExpression* expr);
/// If `expr` is not of an abstract-numeric type, then Materialize() will just return `expr`.
/// * Materialize will create and return a sem::Materialize node wrapping `expr`.
@@ -181,8 +181,8 @@
/// materialized type.
/// If `expr` is not of an abstract-numeric type, then Materialize() will just return `expr`.
/// If `expr` is nullptr, then Materialize() will also return nullptr.
- const sem::Expression* Materialize(const sem::Expression* expr,
- const type::Type* target_type = nullptr);
+ const sem::ValueExpression* Materialize(const sem::ValueExpression* expr,
+ const type::Type* target_type = nullptr);
/// For each argument in `args`:
/// * Calls Materialize() passing the argument and the corresponding parameter type.
@@ -190,7 +190,7 @@
/// reference type.
/// @returns true on success, false on failure.
template <size_t N>
- bool MaybeMaterializeAndLoadArguments(utils::Vector<const sem::Expression*, N>& args,
+ bool MaybeMaterializeAndLoadArguments(utils::Vector<const sem::ValueExpression*, N>& args,
const sem::CallTarget* target);
/// @returns true if an argument of an abstract numeric type, passed to a parameter of type
@@ -206,7 +206,7 @@
/// @returns the vector of constants, `utils::Failure` on failure.
template <size_t N>
utils::Result<utils::Vector<const constant::Value*, N>> ConvertArguments(
- const utils::Vector<const sem::Expression*, N>& args,
+ const utils::Vector<const sem::ValueExpression*, N>& args,
const sem::CallTarget* target);
/// @param ty the type that may hold abstract numeric types
@@ -247,9 +247,9 @@
// CollectTextureSamplerPairs() collects all the texture/sampler pairs from the target function
// / builtin, and records these on the current function by calling AddTextureSamplerPair().
void CollectTextureSamplerPairs(sem::Function* func,
- utils::VectorRef<const sem::Expression*> args) const;
+ utils::VectorRef<const sem::ValueExpression*> args) const;
void CollectTextureSamplerPairs(const sem::Builtin* builtin,
- utils::VectorRef<const sem::Expression*> args) const;
+ utils::VectorRef<const sem::ValueExpression*> args) const;
/// Resolves the WorkgroupSize for the given function, assigning it to
/// current_function_
@@ -459,9 +459,9 @@
/// of determining if any two arguments alias at any callsite.
struct AliasAnalysisInfo {
/// The set of module-scope variables that are written to, and where that write occurs.
- std::unordered_map<const sem::Variable*, const sem::Expression*> module_scope_writes;
+ std::unordered_map<const sem::Variable*, const sem::ValueExpression*> module_scope_writes;
/// The set of module-scope variables that are read from, and where that read occurs.
- std::unordered_map<const sem::Variable*, const sem::Expression*> module_scope_reads;
+ std::unordered_map<const sem::Variable*, const sem::ValueExpression*> module_scope_reads;
/// The set of function parameters that are written to.
std::unordered_set<const sem::Variable*> parameter_writes;
/// The set of function parameters that are read from.
diff --git a/src/tint/resolver/resolver_behavior_test.cc b/src/tint/resolver/resolver_behavior_test.cc
index 6f405a3..960144e 100644
--- a/src/tint/resolver/resolver_behavior_test.cc
+++ b/src/tint/resolver/resolver_behavior_test.cc
@@ -16,10 +16,10 @@
#include "gtest/gtest.h"
#include "src/tint/resolver/resolver_test_helper.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/for_loop_statement.h"
#include "src/tint/sem/if_statement.h"
#include "src/tint/sem/switch_statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/while_statement.h"
using namespace tint::number_suffixes; // NOLINT
diff --git a/src/tint/resolver/resolver_test_helper.h b/src/tint/resolver/resolver_test_helper.h
index d5a6698..f04b697 100644
--- a/src/tint/resolver/resolver_test_helper.h
+++ b/src/tint/resolver/resolver_test_helper.h
@@ -26,8 +26,8 @@
#include "gtest/gtest.h"
#include "src/tint/program_builder.h"
#include "src/tint/resolver/resolver.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/variable.h"
#include "src/tint/traits.h"
#include "src/tint/type/abstract_float.h"
diff --git a/src/tint/resolver/sem_helper.cc b/src/tint/resolver/sem_helper.cc
index db253a7..327b1cf 100644
--- a/src/tint/resolver/sem_helper.cc
+++ b/src/tint/resolver/sem_helper.cc
@@ -14,7 +14,7 @@
#include "src/tint/resolver/sem_helper.h"
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
namespace tint::resolver {
diff --git a/src/tint/resolver/side_effects_test.cc b/src/tint/resolver/side_effects_test.cc
index 081d97c..b0796d5 100644
--- a/src/tint/resolver/side_effects_test.cc
+++ b/src/tint/resolver/side_effects_test.cc
@@ -16,9 +16,9 @@
#include "gtest/gtest.h"
#include "src/tint/resolver/resolver_test_helper.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/index_accessor_expression.h"
#include "src/tint/sem/member_accessor_expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/type/texture_dimension.h"
#include "src/tint/utils/vector.h"
diff --git a/src/tint/resolver/validator.cc b/src/tint/resolver/validator.cc
index 041c528..d6a2950 100644
--- a/src/tint/resolver/validator.cc
+++ b/src/tint/resolver/validator.cc
@@ -384,7 +384,7 @@
bool Validator::VariableInitializer(const ast::Variable* v,
type::AddressSpace address_space,
const type::Type* storage_ty,
- const sem::Expression* initializer) const {
+ const sem::ValueExpression* initializer) const {
auto* initializer_ty = initializer->Type();
auto* value_type = initializer_ty->UnwrapRef(); // Implicit load of RHS
@@ -1343,7 +1343,7 @@
return true;
}
-bool Validator::EvaluationStage(const sem::Expression* expr,
+bool Validator::EvaluationStage(const sem::ValueExpression* expr,
sem::EvaluationStage latest_stage,
std::string_view constraint) const {
if (expr->Stage() == sem::EvaluationStage::kNotEvaluated) {
diff --git a/src/tint/resolver/validator.h b/src/tint/resolver/validator.h
index 6ff3473..55625d3 100644
--- a/src/tint/resolver/validator.h
+++ b/src/tint/resolver/validator.h
@@ -245,7 +245,7 @@
/// @param latest_stage the latest evaluation stage that the expression can be evaluated
/// @param constraint the 'thing' that is imposing the contraint. e.g. "var declaration"
/// @returns true if @p expr is evaluated in or before @p latest_stage, false otherwise
- bool EvaluationStage(const sem::Expression* expr,
+ bool EvaluationStage(const sem::ValueExpression* expr,
sem::EvaluationStage latest_stage,
std::string_view constraint) const;
@@ -436,7 +436,7 @@
bool VariableInitializer(const ast::Variable* v,
type::AddressSpace address_space,
const type::Type* storage_type,
- const sem::Expression* initializer) const;
+ const sem::ValueExpression* initializer) const;
/// Validates a vector
/// @param ty the vector to validate
diff --git a/src/tint/sem/array_count.cc b/src/tint/sem/array_count.cc
index 4fee970..4fa6c08 100644
--- a/src/tint/sem/array_count.cc
+++ b/src/tint/sem/array_count.cc
@@ -40,7 +40,7 @@
return nullptr;
}
-UnnamedOverrideArrayCount::UnnamedOverrideArrayCount(const Expression* e)
+UnnamedOverrideArrayCount::UnnamedOverrideArrayCount(const ValueExpression* e)
: Base(static_cast<size_t>(TypeInfo::Of<UnnamedOverrideArrayCount>().full_hashcode)), expr(e) {}
UnnamedOverrideArrayCount::~UnnamedOverrideArrayCount() = default;
diff --git a/src/tint/sem/array_count.h b/src/tint/sem/array_count.h
index 2d3c27f..9147160 100644
--- a/src/tint/sem/array_count.h
+++ b/src/tint/sem/array_count.h
@@ -17,7 +17,7 @@
#include <string>
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/variable.h"
#include "src/tint/type/array_count.h"
@@ -63,7 +63,7 @@
public:
/// Constructor
/// @param e the override expression
- explicit UnnamedOverrideArrayCount(const Expression* e);
+ explicit UnnamedOverrideArrayCount(const ValueExpression* e);
~UnnamedOverrideArrayCount() override;
/// @param other the other node
@@ -90,7 +90,7 @@
/// ```
// The array count for `a` and `b` have equivalent AST expressions, but the types for `a` and
// `b` must not compare equal.
- const Expression* expr;
+ const ValueExpression* expr;
};
} // namespace tint::sem
diff --git a/src/tint/sem/break_if_statement.h b/src/tint/sem/break_if_statement.h
index bb1e3e5..c5b62de 100644
--- a/src/tint/sem/break_if_statement.h
+++ b/src/tint/sem/break_if_statement.h
@@ -22,7 +22,7 @@
class BreakIfStatement;
} // namespace tint::ast
namespace tint::sem {
-class Expression;
+class ValueExpression;
} // namespace tint::sem
namespace tint::sem {
@@ -45,14 +45,14 @@
const ast::BreakIfStatement* Declaration() const;
/// @returns the break-if-statement condition expression
- const Expression* Condition() const { return condition_; }
+ const ValueExpression* Condition() const { return condition_; }
/// Sets the break-if-statement condition expression
/// @param condition the break-if condition expression
- void SetCondition(const Expression* condition) { condition_ = condition; }
+ void SetCondition(const ValueExpression* condition) { condition_ = condition; }
private:
- const Expression* condition_ = nullptr;
+ const ValueExpression* condition_ = nullptr;
};
} // namespace tint::sem
diff --git a/src/tint/sem/call.cc b/src/tint/sem/call.cc
index 7a28e9f..69485f5 100644
--- a/src/tint/sem/call.cc
+++ b/src/tint/sem/call.cc
@@ -24,7 +24,7 @@
Call::Call(const ast::CallExpression* declaration,
const CallTarget* target,
EvaluationStage stage,
- utils::VectorRef<const sem::Expression*> arguments,
+ utils::VectorRef<const sem::ValueExpression*> arguments,
const Statement* statement,
const constant::Value* constant,
bool has_side_effects)
diff --git a/src/tint/sem/call.h b/src/tint/sem/call.h
index 0873759..3079eb1 100644
--- a/src/tint/sem/call.h
+++ b/src/tint/sem/call.h
@@ -19,14 +19,14 @@
#include "src/tint/ast/call_expression.h"
#include "src/tint/sem/builtin.h"
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/utils/vector.h"
namespace tint::sem {
/// Call is the base class for semantic nodes that hold semantic information for
/// ast::CallExpression nodes.
-class Call final : public Castable<Call, Expression> {
+class Call final : public Castable<Call, ValueExpression> {
public:
/// Constructor
/// @param declaration the AST node
@@ -39,7 +39,7 @@
Call(const ast::CallExpression* declaration,
const CallTarget* target,
EvaluationStage stage,
- utils::VectorRef<const sem::Expression*> arguments,
+ utils::VectorRef<const sem::ValueExpression*> arguments,
const Statement* statement,
const constant::Value* constant,
bool has_side_effects);
@@ -60,7 +60,7 @@
private:
CallTarget const* const target_;
- utils::Vector<const sem::Expression*, 8> arguments_;
+ utils::Vector<const sem::ValueExpression*, 8> arguments_;
};
} // namespace tint::sem
diff --git a/src/tint/sem/for_loop_statement.h b/src/tint/sem/for_loop_statement.h
index 9f7d62a..7e22912 100644
--- a/src/tint/sem/for_loop_statement.h
+++ b/src/tint/sem/for_loop_statement.h
@@ -22,7 +22,7 @@
class ForLoopStatement;
} // namespace tint::ast
namespace tint::sem {
-class Expression;
+class ValueExpression;
} // namespace tint::sem
namespace tint::sem {
@@ -45,14 +45,14 @@
const ast::ForLoopStatement* Declaration() const;
/// @returns the for-loop condition expression
- const Expression* Condition() const { return condition_; }
+ const ValueExpression* Condition() const { return condition_; }
/// Sets the for-loop condition expression
/// @param condition the for-loop condition expression
- void SetCondition(const Expression* condition) { condition_ = condition; }
+ void SetCondition(const ValueExpression* condition) { condition_ = condition; }
private:
- const Expression* condition_ = nullptr;
+ const ValueExpression* condition_ = nullptr;
};
} // namespace tint::sem
diff --git a/src/tint/sem/if_statement.h b/src/tint/sem/if_statement.h
index e9ecda0..5b27fba 100644
--- a/src/tint/sem/if_statement.h
+++ b/src/tint/sem/if_statement.h
@@ -22,7 +22,7 @@
class IfStatement;
} // namespace tint::ast
namespace tint::sem {
-class Expression;
+class ValueExpression;
} // namespace tint::sem
namespace tint::sem {
@@ -45,14 +45,14 @@
const ast::IfStatement* Declaration() const;
/// @returns the if-statement condition expression
- const Expression* Condition() const { return condition_; }
+ const ValueExpression* Condition() const { return condition_; }
/// Sets the if-statement condition expression
/// @param condition the if condition expression
- void SetCondition(const Expression* condition) { condition_ = condition; }
+ void SetCondition(const ValueExpression* condition) { condition_ = condition; }
private:
- const Expression* condition_ = nullptr;
+ const ValueExpression* condition_ = nullptr;
};
} // namespace tint::sem
diff --git a/src/tint/sem/index_accessor_expression.cc b/src/tint/sem/index_accessor_expression.cc
index ed5a468..f407606 100644
--- a/src/tint/sem/index_accessor_expression.cc
+++ b/src/tint/sem/index_accessor_expression.cc
@@ -25,8 +25,8 @@
IndexAccessorExpression::IndexAccessorExpression(const ast::IndexAccessorExpression* declaration,
const type::Type* type,
EvaluationStage stage,
- const Expression* object,
- const Expression* index,
+ const ValueExpression* object,
+ const ValueExpression* index,
const Statement* statement,
const constant::Value* constant,
bool has_side_effects,
diff --git a/src/tint/sem/index_accessor_expression.h b/src/tint/sem/index_accessor_expression.h
index 8327b79..2375a9d 100644
--- a/src/tint/sem/index_accessor_expression.h
+++ b/src/tint/sem/index_accessor_expression.h
@@ -17,7 +17,7 @@
#include <vector>
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
// Forward declarations
namespace tint::ast {
@@ -27,7 +27,7 @@
namespace tint::sem {
/// IndexAccessorExpression holds the semantic information for a ast::IndexAccessorExpression node.
-class IndexAccessorExpression final : public Castable<IndexAccessorExpression, Expression> {
+class IndexAccessorExpression final : public Castable<IndexAccessorExpression, ValueExpression> {
public:
/// Constructor
/// @param declaration the AST node
@@ -42,8 +42,8 @@
IndexAccessorExpression(const ast::IndexAccessorExpression* declaration,
const type::Type* type,
EvaluationStage stage,
- const Expression* object,
- const Expression* index,
+ const ValueExpression* object,
+ const ValueExpression* index,
const Statement* statement,
const constant::Value* constant,
bool has_side_effects,
@@ -53,14 +53,14 @@
~IndexAccessorExpression() override;
/// @returns the object expression that is being indexed
- Expression const* Object() const { return object_; }
+ ValueExpression const* Object() const { return object_; }
/// @returns the index expression
- Expression const* Index() const { return index_; }
+ ValueExpression const* Index() const { return index_; }
private:
- Expression const* const object_;
- Expression const* const index_;
+ ValueExpression const* const object_;
+ ValueExpression const* const index_;
};
} // namespace tint::sem
diff --git a/src/tint/sem/info.cc b/src/tint/sem/info.cc
index a3f5b48..a6a563e 100644
--- a/src/tint/sem/info.cc
+++ b/src/tint/sem/info.cc
@@ -14,10 +14,10 @@
#include "src/tint/sem/info.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/function.h"
#include "src/tint/sem/module.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
namespace tint::sem {
@@ -75,7 +75,7 @@
TINT_ASSERT(Resolver, sem != nullptr);
auto severity = Switch(
sem, //
- [&](const sem::Expression* expr) { return check_stmt(expr->Stmt()); },
+ [&](const sem::ValueExpression* expr) { return check_stmt(expr->Stmt()); },
[&](const sem::Statement* stmt) { return check_stmt(stmt); },
[&](const sem::Function* func) { return check_func(func); },
[&](Default) {
diff --git a/src/tint/sem/load.cc b/src/tint/sem/load.cc
index 58f7068..acabdc7 100644
--- a/src/tint/sem/load.cc
+++ b/src/tint/sem/load.cc
@@ -20,7 +20,7 @@
TINT_INSTANTIATE_TYPEINFO(tint::sem::Load);
namespace tint::sem {
-Load::Load(const Expression* ref, const Statement* statement)
+Load::Load(const ValueExpression* ref, const Statement* statement)
: Base(/* declaration */ ref->Declaration(),
/* type */ ref->Type()->UnwrapRef(),
/* stage */ EvaluationStage::kRuntime, // Loads can only be runtime
diff --git a/src/tint/sem/load.h b/src/tint/sem/load.h
index 1a63266..e02e050 100644
--- a/src/tint/sem/load.h
+++ b/src/tint/sem/load.h
@@ -15,7 +15,7 @@
#ifndef SRC_TINT_SEM_LOAD_H_
#define SRC_TINT_SEM_LOAD_H_
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/type/reference.h"
namespace tint::sem {
@@ -23,18 +23,18 @@
/// Load is a semantic expression which represents the load of a reference to a non-reference value.
/// Loads from reference types are implicit in WGSL, so the Load semantic node shares the same AST
/// node as the inner semantic node.
-class Load final : public Castable<Load, Expression> {
+class Load final : public Castable<Load, ValueExpression> {
public:
/// Constructor
/// @param reference the reference expression being loaded
/// @param statement the statement that owns this expression
- Load(const Expression* reference, const Statement* statement);
+ Load(const ValueExpression* reference, const Statement* statement);
/// Destructor
~Load() override;
/// @return the reference being loaded
- const Expression* Reference() const { return reference_; }
+ const ValueExpression* Reference() const { return reference_; }
/// @returns the type of the loaded reference.
const type::Reference* ReferenceType() const {
@@ -42,7 +42,7 @@
}
private:
- Expression const* const reference_;
+ ValueExpression const* const reference_;
};
} // namespace tint::sem
diff --git a/src/tint/sem/materialize.cc b/src/tint/sem/materialize.cc
index 300deb2..1c27dba 100644
--- a/src/tint/sem/materialize.cc
+++ b/src/tint/sem/materialize.cc
@@ -17,7 +17,7 @@
TINT_INSTANTIATE_TYPEINFO(tint::sem::Materialize);
namespace tint::sem {
-Materialize::Materialize(const Expression* expr,
+Materialize::Materialize(const ValueExpression* expr,
const Statement* statement,
const type::Type* type,
const constant::Value* constant)
diff --git a/src/tint/sem/materialize.h b/src/tint/sem/materialize.h
index 532b3b2..4ce1190 100644
--- a/src/tint/sem/materialize.h
+++ b/src/tint/sem/materialize.h
@@ -15,7 +15,7 @@
#ifndef SRC_TINT_SEM_MATERIALIZE_H_
#define SRC_TINT_SEM_MATERIALIZE_H_
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
namespace tint::sem {
@@ -25,14 +25,14 @@
/// the same AST node as the inner semantic node.
/// Abstract numerics types may only be used by compile-time expressions, so a Materialize semantic
/// node must have a valid Constant value.
-class Materialize final : public Castable<Materialize, Expression> {
+class Materialize final : public Castable<Materialize, ValueExpression> {
public:
/// Constructor
/// @param expr the inner expression, being materialized
/// @param statement the statement that owns this expression
/// @param type concrete type to materialize to
/// @param constant the constant value of this expression or nullptr
- Materialize(const Expression* expr,
+ Materialize(const ValueExpression* expr,
const Statement* statement,
const type::Type* type,
const constant::Value* constant);
@@ -41,10 +41,10 @@
~Materialize() override;
/// @return the expression being materialized
- const Expression* Expr() const { return expr_; }
+ const ValueExpression* Expr() const { return expr_; }
private:
- Expression const* const expr_;
+ ValueExpression const* const expr_;
};
} // namespace tint::sem
diff --git a/src/tint/sem/member_accessor_expression.cc b/src/tint/sem/member_accessor_expression.cc
index 06cfb76..9ad15f0 100644
--- a/src/tint/sem/member_accessor_expression.cc
+++ b/src/tint/sem/member_accessor_expression.cc
@@ -28,7 +28,7 @@
EvaluationStage stage,
const Statement* statement,
const constant::Value* constant,
- const Expression* object,
+ const ValueExpression* object,
bool has_side_effects,
const Variable* root_ident /* = nullptr */)
: Base(declaration, type, stage, statement, constant, has_side_effects, root_ident),
@@ -40,7 +40,7 @@
const type::Type* type,
const Statement* statement,
const constant::Value* constant,
- const Expression* object,
+ const ValueExpression* object,
const StructMember* member,
bool has_side_effects,
const Variable* root_ident /* = nullptr */)
@@ -60,7 +60,7 @@
const type::Type* type,
const Statement* statement,
const constant::Value* constant,
- const Expression* object,
+ const ValueExpression* object,
utils::VectorRef<uint32_t> indices,
bool has_side_effects,
const Variable* root_ident /* = nullptr */)
diff --git a/src/tint/sem/member_accessor_expression.h b/src/tint/sem/member_accessor_expression.h
index 1951afc..7ed0a41 100644
--- a/src/tint/sem/member_accessor_expression.h
+++ b/src/tint/sem/member_accessor_expression.h
@@ -15,7 +15,7 @@
#ifndef SRC_TINT_SEM_MEMBER_ACCESSOR_EXPRESSION_H_
#define SRC_TINT_SEM_MEMBER_ACCESSOR_EXPRESSION_H_
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/utils/vector.h"
// Forward declarations
@@ -30,13 +30,13 @@
/// MemberAccessorExpression holds the semantic information for a
/// ast::MemberAccessorExpression node.
-class MemberAccessorExpression : public Castable<MemberAccessorExpression, Expression> {
+class MemberAccessorExpression : public Castable<MemberAccessorExpression, ValueExpression> {
public:
/// Destructor
~MemberAccessorExpression() override;
/// @returns the object that holds the member being accessed
- const Expression* Object() const { return object_; }
+ const ValueExpression* Object() const { return object_; }
protected:
/// Constructor
@@ -53,12 +53,12 @@
EvaluationStage stage,
const Statement* statement,
const constant::Value* constant,
- const Expression* object,
+ const ValueExpression* object,
bool has_side_effects,
const Variable* root_ident = nullptr);
private:
- Expression const* const object_;
+ ValueExpression const* const object_;
};
/// StructMemberAccess holds the semantic information for a
@@ -79,7 +79,7 @@
const type::Type* type,
const Statement* statement,
const constant::Value* constant,
- const Expression* object,
+ const ValueExpression* object,
const StructMember* member,
bool has_side_effects,
const Variable* root_ident = nullptr);
@@ -111,7 +111,7 @@
const type::Type* type,
const Statement* statement,
const constant::Value* constant,
- const Expression* object,
+ const ValueExpression* object,
utils::VectorRef<uint32_t> indices,
bool has_side_effects,
const Variable* root_ident = nullptr);
diff --git a/src/tint/sem/switch_statement.h b/src/tint/sem/switch_statement.h
index 2476906..503d0a5 100644
--- a/src/tint/sem/switch_statement.h
+++ b/src/tint/sem/switch_statement.h
@@ -31,7 +31,7 @@
namespace tint::sem {
class CaseStatement;
class CaseSelector;
-class Expression;
+class ValueExpression;
} // namespace tint::sem
namespace tint::sem {
diff --git a/src/tint/sem/type_mappings.h b/src/tint/sem/type_mappings.h
index f8aca4d..40e287c 100644
--- a/src/tint/sem/type_mappings.h
+++ b/src/tint/sem/type_mappings.h
@@ -39,16 +39,16 @@
class WhileStatement;
} // namespace tint::ast
namespace tint::sem {
-class Expression;
class ForLoopStatement;
class Function;
+class GlobalVariable;
class IfStatement;
class Node;
-class GlobalVariable;
class Statement;
class Struct;
class StructMember;
class SwitchStatement;
+class ValueExpression;
class Variable;
class WhileStatement;
} // namespace tint::sem
@@ -66,7 +66,6 @@
struct TypeMappings {
//! @cond Doxygen_Suppress
type::Array* operator()(ast::Array*);
- Expression* operator()(ast::Expression*);
ForLoopStatement* operator()(ast::ForLoopStatement*);
Function* operator()(ast::Function*);
IfStatement* operator()(ast::IfStatement*);
@@ -78,6 +77,7 @@
SwitchStatement* operator()(ast::SwitchStatement*);
type::Type* operator()(ast::Type*);
type::Type* operator()(ast::TypeDecl*);
+ ValueExpression* operator()(ast::Expression*);
Variable* operator()(ast::Variable*);
WhileStatement* operator()(ast::WhileStatement*);
//! @endcond
diff --git a/src/tint/sem/expression.cc b/src/tint/sem/value_expression.cc
similarity index 68%
rename from src/tint/sem/expression.cc
rename to src/tint/sem/value_expression.cc
index ebea34c..de3c4cf 100644
--- a/src/tint/sem/expression.cc
+++ b/src/tint/sem/value_expression.cc
@@ -12,24 +12,24 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include <utility>
#include "src/tint/sem/load.h"
#include "src/tint/sem/materialize.h"
-TINT_INSTANTIATE_TYPEINFO(tint::sem::Expression);
+TINT_INSTANTIATE_TYPEINFO(tint::sem::ValueExpression);
namespace tint::sem {
-Expression::Expression(const ast::Expression* declaration,
- const type::Type* type,
- EvaluationStage stage,
- const Statement* statement,
- const constant::Value* constant,
- bool has_side_effects,
- const Variable* root_ident /* = nullptr */)
+ValueExpression::ValueExpression(const ast::Expression* declaration,
+ const type::Type* type,
+ EvaluationStage stage,
+ const Statement* statement,
+ const constant::Value* constant,
+ bool has_side_effects,
+ const Variable* root_ident /* = nullptr */)
: declaration_(declaration),
root_identifier_(root_ident),
type_(type),
@@ -44,23 +44,23 @@
}
}
-Expression::~Expression() = default;
+ValueExpression::~ValueExpression() = default;
-const Expression* Expression::UnwrapMaterialize() const {
+const ValueExpression* ValueExpression::UnwrapMaterialize() const {
if (auto* m = As<Materialize>()) {
return m->Expr();
}
return this;
}
-const Expression* Expression::UnwrapLoad() const {
+const ValueExpression* ValueExpression::UnwrapLoad() const {
if (auto* l = As<Load>()) {
return l->Reference();
}
return this;
}
-const Expression* Expression::Unwrap() const {
+const ValueExpression* ValueExpression::Unwrap() const {
return Switch(
this, // note: An expression can only be wrapped by a Load or Materialize, not both.
[&](const Load* load) { return load->Reference(); },
diff --git a/src/tint/sem/expression.h b/src/tint/sem/value_expression.h
similarity index 81%
rename from src/tint/sem/expression.h
rename to src/tint/sem/value_expression.h
index 575f3f5..9840c11 100644
--- a/src/tint/sem/expression.h
+++ b/src/tint/sem/value_expression.h
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef SRC_TINT_SEM_EXPRESSION_H_
-#define SRC_TINT_SEM_EXPRESSION_H_
+#ifndef SRC_TINT_SEM_VALUE_EXPRESSION_H_
+#define SRC_TINT_SEM_VALUE_EXPRESSION_H_
#include "src/tint/ast/expression.h"
#include "src/tint/constant/value.h"
@@ -29,8 +29,8 @@
namespace tint::sem {
-/// Expression holds the semantic information for expression nodes.
-class Expression : public Castable<Expression, Node> {
+/// ValueExpression holds the semantic information for expression nodes.
+class ValueExpression : public Castable<ValueExpression, Node> {
public:
/// Constructor
/// @param declaration the AST node
@@ -40,16 +40,16 @@
/// @param constant the constant value of the expression. May be null
/// @param has_side_effects true if this expression may have side-effects
/// @param root_ident the (optional) root identifier for this expression
- Expression(const ast::Expression* declaration,
- const type::Type* type,
- EvaluationStage stage,
- const Statement* statement,
- const constant::Value* constant,
- bool has_side_effects,
- const Variable* root_ident = nullptr);
+ ValueExpression(const ast::Expression* declaration,
+ const type::Type* type,
+ EvaluationStage stage,
+ const Statement* statement,
+ const constant::Value* constant,
+ bool has_side_effects,
+ const Variable* root_ident = nullptr);
/// Destructor
- ~Expression() override;
+ ~ValueExpression() override;
/// @returns the AST node
const ast::Expression* Declaration() const { return declaration_; }
@@ -83,13 +83,13 @@
bool HasSideEffects() const { return has_side_effects_; }
/// @return the inner expression node if this is a Materialize, otherwise this.
- const Expression* UnwrapMaterialize() const;
+ const ValueExpression* UnwrapMaterialize() const;
/// @return the inner reference expression if this is a Load, otherwise this.
- const Expression* UnwrapLoad() const;
+ const ValueExpression* UnwrapLoad() const;
/// @return the inner expression node if this is a Materialize or Load, otherwise this.
- const Expression* Unwrap() const;
+ const ValueExpression* Unwrap() const;
protected:
/// The AST expression node for this semantic expression
@@ -108,4 +108,4 @@
} // namespace tint::sem
-#endif // SRC_TINT_SEM_EXPRESSION_H_
+#endif // SRC_TINT_SEM_VALUE_EXPRESSION_H_
diff --git a/src/tint/sem/expression_test.cc b/src/tint/sem/value_expression_test.cc
similarity index 78%
rename from src/tint/sem/expression_test.cc
rename to src/tint/sem/value_expression_test.cc
index 6c49210..1758894 100644
--- a/src/tint/sem/expression_test.cc
+++ b/src/tint/sem/value_expression_test.cc
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/test_helper.h"
@@ -42,14 +42,14 @@
const type::Type* type;
};
-using ExpressionTest = TestHelper;
+using ValueExpressionTest = TestHelper;
-TEST_F(ExpressionTest, UnwrapMaterialize) {
+TEST_F(ValueExpressionTest, UnwrapMaterialize) {
MockConstant c(create<type::I32>());
- auto* a = create<Expression>(/* declaration */ nullptr, create<type::I32>(),
- sem::EvaluationStage::kRuntime, /* statement */ nullptr,
- /* constant_value */ nullptr,
- /* has_side_effects */ false, /* root_ident */ nullptr);
+ auto* a = create<ValueExpression>(/* declaration */ nullptr, create<type::I32>(),
+ sem::EvaluationStage::kRuntime, /* statement */ nullptr,
+ /* constant_value */ nullptr,
+ /* has_side_effects */ false, /* root_ident */ nullptr);
auto* b = create<Materialize>(a, /* statement */ nullptr, c.Type(), &c);
EXPECT_EQ(a, a->UnwrapMaterialize());
diff --git a/src/tint/sem/variable.h b/src/tint/sem/variable.h
index cecad1e..afaa0d1 100644
--- a/src/tint/sem/variable.h
+++ b/src/tint/sem/variable.h
@@ -23,8 +23,8 @@
#include "src/tint/ast/parameter.h"
#include "src/tint/sem/binding_point.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/parameter_usage.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/type/access.h"
#include "src/tint/type/address_space.h"
#include "src/tint/type/type.h"
@@ -84,11 +84,11 @@
/// @returns the variable initializer expression, or nullptr if the variable
/// does not have one.
- const Expression* Initializer() const { return initializer_; }
+ const ValueExpression* Initializer() const { return initializer_; }
/// Sets the variable initializer expression.
/// @param initializer the initializer expression to assign to this variable.
- void SetInitializer(const Expression* initializer) { initializer_ = initializer; }
+ void SetInitializer(const ValueExpression* initializer) { initializer_ = initializer; }
/// @returns the expressions that use the variable
const std::vector<const VariableUser*>& Users() const { return users_; }
@@ -103,7 +103,7 @@
const type::AddressSpace address_space_;
const type::Access access_;
const constant::Value* constant_value_;
- const Expression* initializer_ = nullptr;
+ const ValueExpression* initializer_ = nullptr;
std::vector<const VariableUser*> users_;
};
@@ -255,7 +255,7 @@
/// VariableUser holds the semantic information for an identifier expression
/// node that resolves to a variable.
-class VariableUser final : public Castable<VariableUser, Expression> {
+class VariableUser final : public Castable<VariableUser, ValueExpression> {
public:
/// Constructor
/// @param declaration the AST identifier node
diff --git a/src/tint/sem/while_statement.h b/src/tint/sem/while_statement.h
index 50f1831..fa136bd 100644
--- a/src/tint/sem/while_statement.h
+++ b/src/tint/sem/while_statement.h
@@ -22,7 +22,7 @@
class WhileStatement;
} // namespace tint::ast
namespace tint::sem {
-class Expression;
+class ValueExpression;
} // namespace tint::sem
namespace tint::sem {
@@ -45,14 +45,14 @@
const ast::WhileStatement* Declaration() const;
/// @returns the whilecondition expression
- const Expression* Condition() const { return condition_; }
+ const ValueExpression* Condition() const { return condition_; }
/// Sets the while condition expression
/// @param condition the while condition expression
- void SetCondition(const Expression* condition) { condition_ = condition; }
+ void SetCondition(const ValueExpression* condition) { condition_ = condition; }
private:
- const Expression* condition_ = nullptr;
+ const ValueExpression* condition_ = nullptr;
};
} // namespace tint::sem
diff --git a/src/tint/tint.natvis b/src/tint/tint.natvis
index 71fbd1d..f194135 100644
--- a/src/tint/tint.natvis
+++ b/src/tint/tint.natvis
@@ -260,7 +260,7 @@
<DisplayString>Type={*Type()} Value={Value()}</DisplayString>
</Type>
- <Type Name="tint::sem::Expression">
+ <Type Name="tint::sem::ValueExpression">
<DisplayString>Decl={*declaration_}</DisplayString>
</Type>
diff --git a/src/tint/transform/combine_samplers.cc b/src/tint/transform/combine_samplers.cc
index 65bf161..7a39d6e 100644
--- a/src/tint/transform/combine_samplers.cc
+++ b/src/tint/transform/combine_samplers.cc
@@ -240,14 +240,14 @@
if (texture_index == -1) {
return nullptr;
}
- const sem::Expression* texture =
+ const sem::ValueExpression* texture =
call->Arguments()[static_cast<size_t>(texture_index)];
// We don't want to combine storage textures with anything, since
// they never have associated samplers in GLSL.
if (texture->Type()->UnwrapRef()->Is<type::StorageTexture>()) {
return nullptr;
}
- const sem::Expression* sampler =
+ const sem::ValueExpression* sampler =
sampler_index != -1 ? call->Arguments()[static_cast<size_t>(sampler_index)]
: nullptr;
auto* texture_var = texture->UnwrapLoad()->As<sem::VariableUser>()->Variable();
@@ -296,13 +296,14 @@
const sem::Variable* texture_var = pair.first;
const sem::Variable* sampler_var = pair.second;
if (auto* param = texture_var->As<sem::Parameter>()) {
- const sem::Expression* texture = call->Arguments()[param->Index()];
+ const sem::ValueExpression* texture = call->Arguments()[param->Index()];
texture_var =
texture->UnwrapLoad()->As<sem::VariableUser>()->Variable();
}
if (sampler_var) {
if (auto* param = sampler_var->As<sem::Parameter>()) {
- const sem::Expression* sampler = call->Arguments()[param->Index()];
+ const sem::ValueExpression* sampler =
+ call->Arguments()[param->Index()];
sampler_var =
sampler->UnwrapLoad()->As<sem::VariableUser>()->Variable();
}
diff --git a/src/tint/transform/decompose_memory_access.cc b/src/tint/transform/decompose_memory_access.cc
index abb78b2..0d5f709 100644
--- a/src/tint/transform/decompose_memory_access.cc
+++ b/src/tint/transform/decompose_memory_access.cc
@@ -305,10 +305,10 @@
/// BufferAccess describes a single storage or uniform buffer access
struct BufferAccess {
- sem::Expression const* var = nullptr; // Storage buffer variable
- Offset const* offset = nullptr; // The byte offset on var
- type::Type const* type = nullptr; // The type of the access
- operator bool() const { return var; } // Returns true if valid
+ sem::ValueExpression const* var = nullptr; // Storage buffer variable
+ Offset const* offset = nullptr; // The byte offset on var
+ type::Type const* type = nullptr; // The type of the access
+ operator bool() const { return var; } // Returns true if valid
};
/// Store describes a single storage or uniform buffer write
diff --git a/src/tint/transform/decompose_strided_array.cc b/src/tint/transform/decompose_strided_array.cc
index 129e417..c441df8 100644
--- a/src/tint/transform/decompose_strided_array.cc
+++ b/src/tint/transform/decompose_strided_array.cc
@@ -20,9 +20,9 @@
#include "src/tint/program_builder.h"
#include "src/tint/sem/call.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/member_accessor_expression.h"
#include "src/tint/sem/type_initializer.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/transform/simplify_pointers.h"
#include "src/tint/utils/hash.h"
#include "src/tint/utils/map.h"
diff --git a/src/tint/transform/decompose_strided_matrix.cc b/src/tint/transform/decompose_strided_matrix.cc
index 15cdf62..773cfdf 100644
--- a/src/tint/transform/decompose_strided_matrix.cc
+++ b/src/tint/transform/decompose_strided_matrix.cc
@@ -19,8 +19,8 @@
#include <vector>
#include "src/tint/program_builder.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/member_accessor_expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/transform/simplify_pointers.h"
#include "src/tint/utils/hash.h"
#include "src/tint/utils/map.h"
diff --git a/src/tint/transform/direct_variable_access.cc b/src/tint/transform/direct_variable_access.cc
index c2a4234..2d1b514 100644
--- a/src/tint/transform/direct_variable_access.cc
+++ b/src/tint/transform/direct_variable_access.cc
@@ -151,7 +151,7 @@
struct AccessChain : AccessShape {
/// The array accessor index expressions. This vector is indexed by the `DynamicIndex`s in
/// #indices.
- tint::utils::Vector<const tint::sem::Expression*, 8> dynamic_indices;
+ tint::utils::Vector<const tint::sem::ValueExpression*, 8> dynamic_indices;
/// If true, then this access chain is used as an argument to call a variant.
bool used_in_call = false;
};
@@ -216,7 +216,7 @@
// are grown and moved up the expression tree. After this stage, we are left with all the
// expression access chains to variables that we may need to transform.
for (auto* node : ctx.src->ASTNodes().Objects()) {
- if (auto* expr = sem.Get<sem::Expression>(node)) {
+ if (auto* expr = sem.Get<sem::ValueExpression>(node)) {
AppendAccessChain(expr);
}
}
@@ -361,7 +361,7 @@
/// A map of variant signature to the variant data.
utils::Hashmap<FnVariant::Signature, FnVariant, 8> variants;
/// A map of expressions that have been hoisted to a 'let' declaration in the function.
- utils::Hashmap<const sem::Expression*, Symbol, 8> hoisted_exprs;
+ utils::Hashmap<const sem::ValueExpression*, Symbol, 8> hoisted_exprs;
/// @returns the variants of the function in a deterministically ordered vector.
utils::Vector<std::pair<const FnVariant::Signature*, FnVariant*>, 8> SortedVariants() {
@@ -392,7 +392,7 @@
/// pointer parameter.
utils::Hashmap<AccessShape, Symbol, 8> dynamic_index_array_aliases;
/// Map of semantic expression to AccessChain
- utils::Hashmap<const sem::Expression*, AccessChain*, 32> access_chains;
+ utils::Hashmap<const sem::ValueExpression*, AccessChain*, 32> access_chains;
/// Allocator for FnInfo
utils::BlockAllocator<FnInfo> fn_info_allocator;
/// Allocator for AccessChain
@@ -418,10 +418,10 @@
/// AppendAccessChain creates or extends an existing AccessChain for the given expression,
/// modifying the #access_chains map.
- void AppendAccessChain(const sem::Expression* expr) {
+ void AppendAccessChain(const sem::ValueExpression* expr) {
// take_chain moves the AccessChain from the expression `from` to the expression `expr`.
// Returns nullptr if `from` did not hold an access chain.
- auto take_chain = [&](const sem::Expression* from) -> AccessChain* {
+ auto take_chain = [&](const sem::ValueExpression* from) -> AccessChain* {
if (auto* chain = AccessChainFor(from)) {
access_chains.Remove(from);
access_chains.Add(expr, chain);
@@ -492,7 +492,7 @@
chain->dynamic_indices.Push(a->Index());
}
},
- [&](const sem::Expression* e) {
+ [&](const sem::ValueExpression* e) {
if (auto* unary = e->Declaration()->As<ast::UnaryOpExpression>()) {
// Unary op.
// If this is a '&' or '*', simply move the chain to the unary op expression.
@@ -556,7 +556,7 @@
/// * Casts the resulting expression to a u32 if @p cast_to_u32 is true, and the expression type
/// isn't implicitly usable as a u32. This is to help feed the expression into a
/// `array<u32, N>` argument passed to a callee variant function.
- const ast::Expression* BuildDynamicIndex(const sem::Expression* idx, bool cast_to_u32) {
+ const ast::Expression* BuildDynamicIndex(const sem::ValueExpression* idx, bool cast_to_u32) {
if (auto* val = idx->ConstantValue()) {
// Expression evaluated to a constant value. Just emit that constant.
return b.Expr(val->ValueAs<AInt>());
@@ -766,7 +766,7 @@
/// @returns the AccessChain for the expression @p expr, or nullptr if the expression does
/// not hold an access chain.
- AccessChain* AccessChainFor(const sem::Expression* expr) const {
+ AccessChain* AccessChainFor(const sem::ValueExpression* expr) const {
if (auto chain = access_chains.Find(expr)) {
return *chain;
}
@@ -990,7 +990,7 @@
return nullptr; // Just clone the expression.
}
- auto* expr = sem.Get<sem::Expression>(ast_expr);
+ auto* expr = sem.Get<sem::ValueExpression>(ast_expr);
if (!expr) {
// No semantic node for the expression.
return nullptr; // Just clone the expression.
diff --git a/src/tint/transform/expand_compound_assignment.cc b/src/tint/transform/expand_compound_assignment.cc
index 3d62f23..c208601 100644
--- a/src/tint/transform/expand_compound_assignment.cc
+++ b/src/tint/transform/expand_compound_assignment.cc
@@ -20,9 +20,9 @@
#include "src/tint/ast/increment_decrement_statement.h"
#include "src/tint/program_builder.h"
#include "src/tint/sem/block_statement.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/for_loop_statement.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/transform/utils/hoist_to_decl_before.h"
TINT_INSTANTIATE_TYPEINFO(tint::transform::ExpandCompoundAssignment);
diff --git a/src/tint/transform/localize_struct_array_assignment.cc b/src/tint/transform/localize_struct_array_assignment.cc
index 6ed16b3..0d40ccf 100644
--- a/src/tint/transform/localize_struct_array_assignment.cc
+++ b/src/tint/transform/localize_struct_array_assignment.cc
@@ -20,9 +20,9 @@
#include "src/tint/ast/assignment_statement.h"
#include "src/tint/ast/traverse_expressions.h"
#include "src/tint/program_builder.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/member_accessor_expression.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/sem/variable.h"
#include "src/tint/transform/simplify_pointers.h"
#include "src/tint/type/reference.h"
diff --git a/src/tint/transform/packed_vec3.cc b/src/tint/transform/packed_vec3.cc
index af95161..26cad63 100644
--- a/src/tint/transform/packed_vec3.cc
+++ b/src/tint/transform/packed_vec3.cc
@@ -72,11 +72,11 @@
// Walk the nodes, starting with the most deeply nested, finding all the AST expressions
// that load a whole packed vector (not a scalar / swizzle of the vector).
- utils::Hashset<const sem::Expression*, 16> refs;
+ utils::Hashset<const sem::ValueExpression*, 16> refs;
for (auto* node : ctx.src->ASTNodes().Objects()) {
auto* sem_node = sem.Get(node);
if (sem_node) {
- if (auto* expr = sem_node->As<sem::Expression>()) {
+ if (auto* expr = sem_node->As<sem::ValueExpression>()) {
sem_node = expr->UnwrapLoad();
}
}
@@ -104,7 +104,7 @@
refs.Add(user); // then propagate tracking to pointer usage
}
},
- [&](const sem::Expression* expr) {
+ [&](const sem::ValueExpression* expr) {
if (auto* unary = expr->Declaration()->As<ast::UnaryOpExpression>()) {
if (unary->op == ast::UnaryOp::kAddressOf ||
unary->op == ast::UnaryOp::kIndirection) {
diff --git a/src/tint/transform/promote_initializers_to_let.cc b/src/tint/transform/promote_initializers_to_let.cc
index 391a7f2..0ad37de 100644
--- a/src/tint/transform/promote_initializers_to_let.cc
+++ b/src/tint/transform/promote_initializers_to_let.cc
@@ -41,7 +41,7 @@
// Returns true if the expression should be hoisted to a new let statement before the
// expression's statement.
- auto should_hoist = [&](const sem::Expression* expr) {
+ auto should_hoist = [&](const sem::ValueExpression* expr) {
if (!expr->Type()->IsAnyOf<type::Array, type::Struct>()) {
// We only care about array and struct initializers
return false;
@@ -77,13 +77,13 @@
};
// A list of expressions that should be hoisted.
- utils::Vector<const sem::Expression*, 32> to_hoist;
+ utils::Vector<const sem::ValueExpression*, 32> to_hoist;
// A set of expressions that are constant, which _may_ need to be hoisted.
utils::Hashset<const ast::Expression*, 32> const_chains;
// Walk the AST nodes. This order guarantees that leaf-expressions are visited first.
for (auto* node : src->ASTNodes().Objects()) {
- if (auto* sem = src->Sem().Get<sem::Expression>(node)) {
+ if (auto* sem = src->Sem().Get<sem::ValueExpression>(node)) {
auto* stmt = sem->Stmt();
if (!stmt) {
// Expression is outside of a statement. This usually means the expression is part
diff --git a/src/tint/transform/promote_side_effects_to_decl.cc b/src/tint/transform/promote_side_effects_to_decl.cc
index 2d4b059..632d57b 100644
--- a/src/tint/transform/promote_side_effects_to_decl.cc
+++ b/src/tint/transform/promote_side_effects_to_decl.cc
@@ -107,7 +107,7 @@
std::unordered_set<const ast::Expression*> no_side_effects;
// Returns true if `expr` has side-effects. Unlike invoking
- // sem::Expression::HasSideEffects(), this function takes into account whether
+ // sem::ValueExpression::HasSideEffects(), this function takes into account whether
// `expr` has been hoisted, returning false in that case. Furthermore, it
// returns the correct result on parent expression nodes by traversing the
// expression tree, memoizing the results to ensure O(1) amortized lookup.
diff --git a/src/tint/transform/robustness.cc b/src/tint/transform/robustness.cc
index 1d624df..4680939 100644
--- a/src/tint/transform/robustness.cc
+++ b/src/tint/transform/robustness.cc
@@ -21,9 +21,9 @@
#include "src/tint/program_builder.h"
#include "src/tint/sem/block_statement.h"
#include "src/tint/sem/call.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/index_accessor_expression.h"
#include "src/tint/sem/statement.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/type/reference.h"
TINT_INSTANTIATE_TYPEINFO(tint::transform::Robustness);
diff --git a/src/tint/transform/spirv_atomic.cc b/src/tint/transform/spirv_atomic.cc
index 9ad5b3e..07879e8 100644
--- a/src/tint/transform/spirv_atomic.cc
+++ b/src/tint/transform/spirv_atomic.cc
@@ -54,7 +54,7 @@
CloneContext ctx = {&b, src, /* auto_clone_symbols */ true};
std::unordered_map<const ast::Struct*, ForkedStruct> forked_structs;
std::unordered_set<const sem::Variable*> atomic_variables;
- utils::UniqueVector<const sem::Expression*, 8> atomic_expressions;
+ utils::UniqueVector<const sem::ValueExpression*, 8> atomic_expressions;
public:
/// Constructor
@@ -184,7 +184,7 @@
[&](const sem::IndexAccessorExpression* index) {
atomic_expressions.Add(index->Object());
},
- [&](const sem::Expression* e) {
+ [&](const sem::ValueExpression* e) {
if (auto* unary = e->Declaration()->As<ast::UnaryOpExpression>()) {
atomic_expressions.Add(ctx.src->Sem().Get(unary->expr));
}
@@ -226,7 +226,7 @@
void ReplaceLoadsAndStores() {
// Returns true if 'e' is a reference to an atomic variable or struct member
- auto is_ref_to_atomic_var = [&](const sem::Expression* e) {
+ auto is_ref_to_atomic_var = [&](const sem::ValueExpression* e) {
if (tint::Is<type::Reference>(e->Type()) && e->RootIdentifier() &&
(atomic_variables.count(e->RootIdentifier()) != 0)) {
// If it's a struct member, make sure it's one we marked as atomic
diff --git a/src/tint/transform/std140.cc b/src/tint/transform/std140.cc
index c66e396..cde4a3f 100644
--- a/src/tint/transform/std140.cc
+++ b/src/tint/transform/std140.cc
@@ -251,7 +251,7 @@
/// The chain of access indices, starting with the first access on #var.
AccessIndices indices;
/// The runtime-evaluated expressions. This vector is indexed by the DynamicIndex::slot
- utils::Vector<const sem::Expression*, 8> dynamic_indices;
+ utils::Vector<const sem::ValueExpression*, 8> dynamic_indices;
/// The type of the std140-decomposed matrix being accessed.
/// May be nullptr if the chain does not pass through a std140-decomposed matrix.
const type::Matrix* std140_mat_ty = nullptr;
@@ -573,7 +573,7 @@
expr = s->Object();
return Action::kContinue;
},
- [&](const sem::Expression* e) {
+ [&](const sem::ValueExpression* e) {
// Walk past indirection and address-of unary ops.
return Switch(e->Declaration(), //
[&](const ast::UnaryOpExpression* u) {
@@ -797,7 +797,7 @@
});
// Build the arguments
- auto args = utils::Transform(access.dynamic_indices, [&](const sem::Expression* e) {
+ auto args = utils::Transform(access.dynamic_indices, [&](const sem::ValueExpression* e) {
return b.Construct(b.ty.u32(), ctx.Clone(e->Declaration()));
});
diff --git a/src/tint/transform/utils/hoist_to_decl_before.cc b/src/tint/transform/utils/hoist_to_decl_before.cc
index 5852573..fd7402e 100644
--- a/src/tint/transform/utils/hoist_to_decl_before.cc
+++ b/src/tint/transform/utils/hoist_to_decl_before.cc
@@ -36,7 +36,7 @@
explicit State(CloneContext& ctx_in) : ctx(ctx_in), b(*ctx_in.dst) {}
/// @copydoc HoistToDeclBefore::Add()
- bool Add(const sem::Expression* before_expr,
+ bool Add(const sem::ValueExpression* before_expr,
const ast::Expression* expr,
VariableKind kind,
const char* decl_name) {
@@ -94,7 +94,7 @@
}
/// @copydoc HoistToDeclBefore::Prepare()
- bool Prepare(const sem::Expression* before_expr) {
+ bool Prepare(const sem::ValueExpression* before_expr) {
return InsertBefore(before_expr->Stmt(), nullptr);
}
@@ -376,7 +376,7 @@
HoistToDeclBefore::~HoistToDeclBefore() {}
-bool HoistToDeclBefore::Add(const sem::Expression* before_expr,
+bool HoistToDeclBefore::Add(const sem::ValueExpression* before_expr,
const ast::Expression* expr,
VariableKind kind,
const char* decl_name) {
@@ -393,7 +393,7 @@
return state_->InsertBefore(before_stmt, builder);
}
-bool HoistToDeclBefore::Prepare(const sem::Expression* before_expr) {
+bool HoistToDeclBefore::Prepare(const sem::ValueExpression* before_expr) {
return state_->Prepare(before_expr);
}
diff --git a/src/tint/transform/utils/hoist_to_decl_before.h b/src/tint/transform/utils/hoist_to_decl_before.h
index 4d6a808..81c255f 100644
--- a/src/tint/transform/utils/hoist_to_decl_before.h
+++ b/src/tint/transform/utils/hoist_to_decl_before.h
@@ -18,7 +18,7 @@
#include <functional>
#include <memory>
-#include "src/tint/sem/expression.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/transform/transform.h"
namespace tint::transform {
@@ -52,7 +52,7 @@
/// @param kind variable kind to hoist to
/// @param decl_name optional name to use for the variable/constant name
/// @return true on success
- bool Add(const sem::Expression* before_expr,
+ bool Add(const sem::ValueExpression* before_expr,
const ast::Expression* expr,
VariableKind kind,
const char* decl_name = "");
@@ -81,7 +81,7 @@
/// needed.
/// @param before_expr expression we would hoist a decl before
/// @return true on success
- bool Prepare(const sem::Expression* before_expr);
+ bool Prepare(const sem::ValueExpression* before_expr);
private:
struct State;
diff --git a/src/tint/transform/vectorize_matrix_conversions.cc b/src/tint/transform/vectorize_matrix_conversions.cc
index 26f27c3..f22e32d 100644
--- a/src/tint/transform/vectorize_matrix_conversions.cc
+++ b/src/tint/transform/vectorize_matrix_conversions.cc
@@ -20,8 +20,8 @@
#include "src/tint/program_builder.h"
#include "src/tint/sem/call.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/type_conversion.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/type/abstract_numeric.h"
#include "src/tint/utils/hash.h"
#include "src/tint/utils/map.h"
@@ -34,7 +34,7 @@
bool ShouldRun(const Program* program) {
for (auto* node : program->ASTNodes().Objects()) {
- if (auto* sem = program->Sem().Get<sem::Expression>(node)) {
+ if (auto* sem = program->Sem().Get<sem::ValueExpression>(node)) {
if (auto* call = sem->UnwrapMaterialize()->As<sem::Call>()) {
if (call->Target()->Is<sem::TypeConversion>() && call->Type()->Is<type::Matrix>()) {
auto& args = call->Arguments();
diff --git a/src/tint/transform/vectorize_scalar_matrix_initializers.cc b/src/tint/transform/vectorize_scalar_matrix_initializers.cc
index 9e989bc..60d4d13 100644
--- a/src/tint/transform/vectorize_scalar_matrix_initializers.cc
+++ b/src/tint/transform/vectorize_scalar_matrix_initializers.cc
@@ -19,8 +19,8 @@
#include "src/tint/program_builder.h"
#include "src/tint/sem/call.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/type_initializer.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/type/abstract_numeric.h"
#include "src/tint/utils/map.h"
diff --git a/src/tint/writer/append_vector.cc b/src/tint/writer/append_vector.cc
index ab0ab70..c39c619 100644
--- a/src/tint/writer/append_vector.cc
+++ b/src/tint/writer/append_vector.cc
@@ -18,9 +18,9 @@
#include <vector>
#include "src/tint/sem/call.h"
-#include "src/tint/sem/expression.h"
#include "src/tint/sem/type_conversion.h"
#include "src/tint/sem/type_initializer.h"
+#include "src/tint/sem/value_expression.h"
#include "src/tint/utils/transform.h"
using namespace tint::number_suffixes; // NOLINT
@@ -33,7 +33,7 @@
const sem::TypeInitializer* ctor = nullptr;
operator bool() const { return call != nullptr; }
};
-VectorInitializerInfo AsVectorInitializer(const sem::Expression* expr) {
+VectorInitializerInfo AsVectorInitializer(const sem::ValueExpression* expr) {
if (auto* call = expr->As<sem::Call>()) {
if (auto* ctor = call->Target()->As<sem::TypeInitializer>()) {
if (ctor->ReturnType()->Is<type::Vector>()) {
@@ -44,7 +44,9 @@
return {};
}
-const sem::Expression* Zero(ProgramBuilder& b, const type::Type* ty, const sem::Statement* stmt) {
+const sem::ValueExpression* Zero(ProgramBuilder& b,
+ const type::Type* ty,
+ const sem::Statement* stmt) {
const ast::Expression* expr = nullptr;
if (ty->Is<type::I32>()) {
expr = b.Expr(0_i);
@@ -59,9 +61,9 @@
<< "unsupported vector element type: " << ty->TypeInfo().name;
return nullptr;
}
- auto* sem = b.create<sem::Expression>(expr, ty, sem::EvaluationStage::kRuntime, stmt,
- /* constant_value */ nullptr,
- /* has_side_effects */ false);
+ auto* sem = b.create<sem::ValueExpression>(expr, ty, sem::EvaluationStage::kRuntime, stmt,
+ /* constant_value */ nullptr,
+ /* has_side_effects */ false);
b.Sem().Add(expr, sem);
return sem;
}
@@ -112,7 +114,7 @@
// to convert a vector of a different type, e.g. vec2<i32>(vec2<u32>()).
// In that case, preserve the original argument, or you'll get a type error.
- utils::Vector<const sem::Expression*, 4> packed;
+ utils::Vector<const sem::ValueExpression*, 4> packed;
if (auto vc = AsVectorInitializer(vector_sem)) {
const auto num_supplied = vc.call->Arguments().Length();
if (num_supplied == 0) {
@@ -141,7 +143,7 @@
sem::EvaluationStage::kRuntime);
auto* scalar_cast_sem = b->create<sem::Call>(
scalar_cast_ast, scalar_cast_target, sem::EvaluationStage::kRuntime,
- utils::Vector<const sem::Expression*, 1>{scalar_sem}, statement,
+ utils::Vector<const sem::ValueExpression*, 1>{scalar_sem}, statement,
/* constant_value */ nullptr, /* has_side_effects */ false);
b->Sem().Add(scalar_cast_ast, scalar_cast_sem);
packed.Push(scalar_cast_sem);
@@ -149,17 +151,19 @@
packed.Push(scalar_sem);
}
- auto* initializer_ast = b->Construct(
- packed_ast_ty,
- utils::Transform(packed, [&](const sem::Expression* expr) { return expr->Declaration(); }));
+ auto* initializer_ast =
+ b->Construct(packed_ast_ty, utils::Transform(packed, [&](const sem::ValueExpression* expr) {
+ return expr->Declaration();
+ }));
auto* initializer_target = b->create<sem::TypeInitializer>(
packed_sem_ty,
- utils::Transform(packed,
- [&](const tint::sem::Expression* arg, size_t i) -> const sem::Parameter* {
- return b->create<sem::Parameter>(
- nullptr, static_cast<uint32_t>(i), arg->Type()->UnwrapRef(),
- type::AddressSpace::kNone, type::Access::kUndefined);
- }),
+ utils::Transform(
+ packed,
+ [&](const tint::sem::ValueExpression* arg, size_t i) -> const sem::Parameter* {
+ return b->create<sem::Parameter>(
+ nullptr, static_cast<uint32_t>(i), arg->Type()->UnwrapRef(),
+ type::AddressSpace::kNone, type::Access::kUndefined);
+ }),
sem::EvaluationStage::kRuntime);
auto* initializer_sem =
b->create<sem::Call>(initializer_ast, initializer_target, sem::EvaluationStage::kRuntime,
diff --git a/src/tint/writer/glsl/generator_impl.cc b/src/tint/writer/glsl/generator_impl.cc
index 8461e51..3009355 100644
--- a/src/tint/writer/glsl/generator_impl.cc
+++ b/src/tint/writer/glsl/generator_impl.cc
@@ -1313,9 +1313,9 @@
const ast::Expression* GeneratorImpl::CreateF32Zero(const sem::Statement* stmt) {
auto* zero = builder_.Expr(0_f);
auto* f32 = builder_.create<type::F32>();
- auto* sem_zero = builder_.create<sem::Expression>(zero, f32, sem::EvaluationStage::kRuntime,
- stmt, /* constant_value */ nullptr,
- /* has_side_effects */ false);
+ auto* sem_zero = builder_.create<sem::ValueExpression>(
+ zero, f32, sem::EvaluationStage::kRuntime, stmt, /* constant_value */ nullptr,
+ /* has_side_effects */ false);
builder_.Sem().Add(zero, sem_zero);
return zero;
}
diff --git a/src/tint/writer/hlsl/generator_impl.cc b/src/tint/writer/hlsl/generator_impl.cc
index f6524d3..014cb88 100644
--- a/src/tint/writer/hlsl/generator_impl.cc
+++ b/src/tint/writer/hlsl/generator_impl.cc
@@ -2569,10 +2569,10 @@
auto* i32 = builder_.create<type::I32>();
auto* zero = builder_.Expr(0_i);
auto* stmt = builder_.Sem().Get(vector)->Stmt();
- builder_.Sem().Add(
- zero, builder_.create<sem::Expression>(zero, i32, sem::EvaluationStage::kRuntime, stmt,
- /* constant_value */ nullptr,
- /* has_side_effects */ false));
+ builder_.Sem().Add(zero, builder_.create<sem::ValueExpression>(
+ zero, i32, sem::EvaluationStage::kRuntime, stmt,
+ /* constant_value */ nullptr,
+ /* has_side_effects */ false));
auto* packed = AppendVector(&builder_, vector, zero);
return EmitExpression(out, packed->Declaration());
};
diff --git a/src/tint/writer/spirv/builder.cc b/src/tint/writer/spirv/builder.cc
index fab7744..b36d89f 100644
--- a/src/tint/writer/spirv/builder.cc
+++ b/src/tint/writer/spirv/builder.cc
@@ -558,7 +558,7 @@
return true;
}
-uint32_t Builder::GenerateExpression(const sem::Expression* expr) {
+uint32_t Builder::GenerateExpression(const sem::ValueExpression* expr) {
if (auto* constant = expr->ConstantValue()) {
return GenerateConstantIfNeeded(constant);
}
@@ -2625,7 +2625,7 @@
auto& arguments = call->Arguments();
// Generates the given expression, returning the operand ID
- auto gen = [&](const sem::Expression* expr) { return Operand(GenerateExpression(expr)); };
+ auto gen = [&](const sem::ValueExpression* expr) { return Operand(GenerateExpression(expr)); };
// Returns the argument with the given usage
auto arg = [&](Usage usage) {
diff --git a/src/tint/writer/spirv/builder.h b/src/tint/writer/spirv/builder.h
index 12e16c1..0695a9c 100644
--- a/src/tint/writer/spirv/builder.h
+++ b/src/tint/writer/spirv/builder.h
@@ -275,7 +275,7 @@
/// Generates an expression
/// @param expr the expression to generate
/// @returns the resulting ID of the expression or 0 on error
- uint32_t GenerateExpression(const sem::Expression* expr);
+ uint32_t GenerateExpression(const sem::ValueExpression* expr);
/// Generates an expression
/// @param expr the expression to generate
/// @returns the resulting ID of the expression or 0 on error
