[tint][ir] Rename Builtin and rename Builder Call methods
Rename Builtin to BuiltinCall to match UserCall.
Rename both Builder::UserCall() and Builder::Builtin() to
Builder::Call().
Change-Id: Ia7fb9720482203d85e3f8642c63f8d4b7139df55
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/136604
Commit-Queue: Ben Clayton <bclayton@google.com>
Reviewed-by: James Price <jrprice@google.com>
Kokoro: Ben Clayton <bclayton@google.com>
diff --git a/src/tint/BUILD.gn b/src/tint/BUILD.gn
index c18546b..2b450fb 100644
--- a/src/tint/BUILD.gn
+++ b/src/tint/BUILD.gn
@@ -1234,8 +1234,8 @@
"ir/break_if.h",
"ir/builder.cc",
"ir/builder.h",
- "ir/builtin.cc",
- "ir/builtin.h",
+ "ir/builtin_call.cc",
+ "ir/builtin_call.h",
"ir/call.cc",
"ir/call.h",
"ir/constant.cc",
@@ -2308,7 +2308,7 @@
"ir/block_param_test.cc",
"ir/block_test.cc",
"ir/break_if_test.cc",
- "ir/builtin_test.cc",
+ "ir/builtin_call_test.cc",
"ir/constant_test.cc",
"ir/construct_test.cc",
"ir/continue_test.cc",
diff --git a/src/tint/CMakeLists.txt b/src/tint/CMakeLists.txt
index c901e3b..6e6d760 100644
--- a/src/tint/CMakeLists.txt
+++ b/src/tint/CMakeLists.txt
@@ -737,8 +737,8 @@
ir/break_if.h
ir/builder.cc
ir/builder.h
- ir/builtin.cc
- ir/builtin.h
+ ir/builtin_call.cc
+ ir/builtin_call.h
ir/call.cc
ir/call.h
ir/constant.cc
@@ -1509,7 +1509,7 @@
ir/block_param_test.cc
ir/block_test.cc
ir/break_if_test.cc
- ir/builtin_test.cc
+ ir/builtin_call_test.cc
ir/constant_test.cc
ir/construct_test.cc
ir/continue_test.cc
diff --git a/src/tint/ir/builder.cc b/src/tint/ir/builder.cc
index 4288954..5006007 100644
--- a/src/tint/ir/builder.cc
+++ b/src/tint/ir/builder.cc
@@ -166,9 +166,7 @@
return ir.values.Create<ir::Discard>(ir.Types().void_());
}
-ir::UserCall* Builder::UserCall(const type::Type* type,
- Function* func,
- utils::VectorRef<Value*> args) {
+ir::UserCall* Builder::Call(const type::Type* type, Function* func, utils::VectorRef<Value*> args) {
return ir.values.Create<ir::UserCall>(type, func, std::move(args));
}
@@ -182,10 +180,10 @@
return ir.values.Create<ir::Construct>(to, std::move(args));
}
-ir::Builtin* Builder::Builtin(const type::Type* type,
- builtin::Function func,
- utils::VectorRef<Value*> args) {
- return ir.values.Create<ir::Builtin>(type, func, args);
+ir::BuiltinCall* Builder::Call(const type::Type* type,
+ builtin::Function func,
+ utils::VectorRef<Value*> args) {
+ return ir.values.Create<ir::BuiltinCall>(type, func, args);
}
ir::Load* Builder::Load(Value* from) {
diff --git a/src/tint/ir/builder.h b/src/tint/ir/builder.h
index 7c87272..ffc281b 100644
--- a/src/tint/ir/builder.h
+++ b/src/tint/ir/builder.h
@@ -23,7 +23,7 @@
#include "src/tint/ir/bitcast.h"
#include "src/tint/ir/block_param.h"
#include "src/tint/ir/break_if.h"
-#include "src/tint/ir/builtin.h"
+#include "src/tint/ir/builtin_call.h"
#include "src/tint/ir/constant.h"
#include "src/tint/ir/construct.h"
#include "src/tint/ir/continue.h"
@@ -297,9 +297,18 @@
/// @param func the function being called
/// @param args the call arguments
/// @returns the instruction
- ir::UserCall* UserCall(const type::Type* type,
- Function* func,
- utils::VectorRef<Value*> args = utils::Empty);
+ ir::UserCall* Call(const type::Type* type,
+ Function* func,
+ utils::VectorRef<Value*> args = utils::Empty);
+
+ /// Creates a builtin call instruction
+ /// @param type the return type
+ /// @param func the builtin function
+ /// @param args the call arguments
+ /// @returns the instruction
+ ir::BuiltinCall* Call(const type::Type* type,
+ builtin::Function func,
+ utils::VectorRef<Value*> args = utils::Empty);
/// Creates a value conversion instruction
/// @param to the type converted to
@@ -316,15 +325,6 @@
/// @returns the instruction
ir::Construct* Construct(const type::Type* to, utils::VectorRef<Value*> args = utils::Empty);
- /// Creates a builtin call instruction
- /// @param type the return type
- /// @param func the builtin function
- /// @param args the arguments to be converted
- /// @returns the instruction
- ir::Builtin* Builtin(const type::Type* type,
- builtin::Function func,
- utils::VectorRef<Value*> args = utils::Empty);
-
/// Creates a load instruction
/// @param from the expression being loaded from
/// @returns the instruction
diff --git a/src/tint/ir/builtin.cc b/src/tint/ir/builtin_call.cc
similarity index 75%
rename from src/tint/ir/builtin.cc
rename to src/tint/ir/builtin_call.cc
index c571168..a230510 100644
--- a/src/tint/ir/builtin.cc
+++ b/src/tint/ir/builtin_call.cc
@@ -12,25 +12,25 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "src/tint/ir/builtin.h"
+#include "src/tint/ir/builtin_call.h"
#include <utility>
#include "src/tint/debug.h"
-TINT_INSTANTIATE_TYPEINFO(tint::ir::Builtin);
+TINT_INSTANTIATE_TYPEINFO(tint::ir::BuiltinCall);
-// \cond DO_NOT_DOCUMENT
namespace tint::ir {
-Builtin::Builtin(const type::Type* ty, builtin::Function func, utils::VectorRef<Value*> arguments)
+BuiltinCall::BuiltinCall(const type::Type* ty,
+ builtin::Function func,
+ utils::VectorRef<Value*> arguments)
: Base(ty), func_(func) {
TINT_ASSERT(IR, func != builtin::Function::kNone);
TINT_ASSERT(IR, func != builtin::Function::kTintMaterialize);
AddOperands(std::move(arguments));
}
-Builtin::~Builtin() = default;
+BuiltinCall::~BuiltinCall() = default;
} // namespace tint::ir
-// \endcond
diff --git a/src/tint/ir/builtin.h b/src/tint/ir/builtin_call.h
similarity index 75%
rename from src/tint/ir/builtin.h
rename to src/tint/ir/builtin_call.h
index 727b231..4aef1eb 100644
--- a/src/tint/ir/builtin.h
+++ b/src/tint/ir/builtin_call.h
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef SRC_TINT_IR_BUILTIN_H_
-#define SRC_TINT_IR_BUILTIN_H_
+#ifndef SRC_TINT_IR_BUILTIN_CALL_H_
+#define SRC_TINT_IR_BUILTIN_CALL_H_
#include "src/tint/builtin/function.h"
#include "src/tint/ir/call.h"
@@ -22,16 +22,16 @@
namespace tint::ir {
/// A builtin call instruction in the IR.
-class Builtin : public utils::Castable<Builtin, Call> {
+class BuiltinCall : public utils::Castable<BuiltinCall, Call> {
public:
/// Constructor
/// @param res_type the result type
/// @param func the builtin function
/// @param args the conversion arguments
- Builtin(const type::Type* res_type,
- builtin::Function func,
- utils::VectorRef<Value*> args = utils::Empty);
- ~Builtin() override;
+ BuiltinCall(const type::Type* res_type,
+ builtin::Function func,
+ utils::VectorRef<Value*> args = utils::Empty);
+ ~BuiltinCall() override;
/// @returns the builtin function
builtin::Function Func() { return func_; }
@@ -42,4 +42,4 @@
} // namespace tint::ir
-#endif // SRC_TINT_IR_BUILTIN_H_
+#endif // SRC_TINT_IR_BUILTIN_CALL_H_
diff --git a/src/tint/ir/builtin_test.cc b/src/tint/ir/builtin_call_test.cc
similarity index 69%
rename from src/tint/ir/builtin_test.cc
rename to src/tint/ir/builtin_call_test.cc
index d5cf04a..ab7471a 100644
--- a/src/tint/ir/builtin_test.cc
+++ b/src/tint/ir/builtin_call_test.cc
@@ -21,55 +21,53 @@
namespace {
using namespace tint::number_suffixes; // NOLINT
-using IR_BuiltinTest = IRTestHelper;
+using IR_BuiltinCallTest = IRTestHelper;
-TEST_F(IR_BuiltinTest, Usage) {
+TEST_F(IR_BuiltinCallTest, Usage) {
auto* arg1 = b.Constant(1_u);
auto* arg2 = b.Constant(2_u);
- auto* builtin =
- b.Builtin(mod.Types().f32(), builtin::Function::kAbs, utils::Vector{arg1, arg2});
+ auto* builtin = b.Call(mod.Types().f32(), builtin::Function::kAbs, utils::Vector{arg1, arg2});
EXPECT_THAT(arg1->Usages(), testing::UnorderedElementsAre(Usage{builtin, 0u}));
EXPECT_THAT(arg2->Usages(), testing::UnorderedElementsAre(Usage{builtin, 1u}));
}
-TEST_F(IR_BuiltinTest, Fail_NullType) {
+TEST_F(IR_BuiltinCallTest, Fail_NullType) {
EXPECT_FATAL_FAILURE(
{
Module mod;
Builder b{mod};
- b.Builtin(nullptr, builtin::Function::kAbs);
+ b.Call(nullptr, builtin::Function::kAbs);
},
"");
}
-TEST_F(IR_BuiltinTest, Fail_NoneFunction) {
+TEST_F(IR_BuiltinCallTest, Fail_NoneFunction) {
EXPECT_FATAL_FAILURE(
{
Module mod;
Builder b{mod};
- b.Builtin(mod.Types().f32(), builtin::Function::kNone);
+ b.Call(mod.Types().f32(), builtin::Function::kNone);
},
"");
}
-TEST_F(IR_BuiltinTest, Fail_TintMaterializeFunction) {
+TEST_F(IR_BuiltinCallTest, Fail_TintMaterializeFunction) {
EXPECT_FATAL_FAILURE(
{
Module mod;
Builder b{mod};
- b.Builtin(mod.Types().f32(), builtin::Function::kTintMaterialize);
+ b.Call(mod.Types().f32(), builtin::Function::kTintMaterialize);
},
"");
}
-TEST_F(IR_BuiltinTest, Fail_NullArg) {
+TEST_F(IR_BuiltinCallTest, Fail_NullArg) {
EXPECT_FATAL_FAILURE(
{
Module mod;
Builder b{mod};
- b.Builtin(mod.Types().f32(), builtin::Function::kAbs,
- utils::Vector<Value*, 1>{nullptr});
+ b.Call(mod.Types().f32(), builtin::Function::kAbs, utils::Vector<Value*, 1>{nullptr});
},
"");
}
diff --git a/src/tint/ir/disassembler.cc b/src/tint/ir/disassembler.cc
index e12b08d..180eb40 100644
--- a/src/tint/ir/disassembler.cc
+++ b/src/tint/ir/disassembler.cc
@@ -24,7 +24,7 @@
#include "src/tint/ir/block.h"
#include "src/tint/ir/block_param.h"
#include "src/tint/ir/break_if.h"
-#include "src/tint/ir/builtin.h"
+#include "src/tint/ir/builtin_call.h"
#include "src/tint/ir/construct.h"
#include "src/tint/ir/continue.h"
#include "src/tint/ir/convert.h"
@@ -370,7 +370,7 @@
EmitInstructionName("discard", d);
EmitLine();
},
- [&](Builtin* b) {
+ [&](BuiltinCall* b) {
EmitValueWithType(b);
out_ << " = ";
EmitInstructionName(builtin::str(b->Func()), b);
diff --git a/src/tint/ir/from_program.cc b/src/tint/ir/from_program.cc
index 338c6d0..b80c31e 100644
--- a/src/tint/ir/from_program.cc
+++ b/src/tint/ir/from_program.cc
@@ -1362,7 +1362,7 @@
// If this is a builtin function, emit the specific builtin value
if (auto* b = sem->Target()->As<sem::Builtin>()) {
- inst = builder_.Builtin(ty, b->Type(), args);
+ inst = builder_.Call(ty, b->Type(), args);
} else if (sem->Target()->As<sem::ValueConstructor>()) {
inst = builder_.Construct(ty, std::move(args));
} else if (auto* conv = sem->Target()->As<sem::ValueConversion>()) {
@@ -1373,9 +1373,9 @@
return utils::Failure;
} else {
// Not a builtin and not a templated call, so this is a user function.
- inst = builder_.UserCall(
- ty, scopes_.Get(expr->target->identifier->symbol)->As<ir::Function>(),
- std::move(args));
+ inst =
+ builder_.Call(ty, scopes_.Get(expr->target->identifier->symbol)->As<ir::Function>(),
+ std::move(args));
}
if (inst == nullptr) {
return utils::Failure;
diff --git a/src/tint/ir/user_call_test.cc b/src/tint/ir/user_call_test.cc
index 2fd9151..ed060b6 100644
--- a/src/tint/ir/user_call_test.cc
+++ b/src/tint/ir/user_call_test.cc
@@ -28,7 +28,7 @@
auto* func = b.CreateFunction("myfunc", mod.Types().void_());
auto* arg1 = b.Constant(1_u);
auto* arg2 = b.Constant(2_u);
- auto* e = b.UserCall(mod.Types().void_(), func, utils::Vector{arg1, arg2});
+ auto* e = b.Call(mod.Types().void_(), func, utils::Vector{arg1, arg2});
EXPECT_THAT(func->Usages(), testing::UnorderedElementsAre(Usage{e, 0u}));
EXPECT_THAT(arg1->Usages(), testing::UnorderedElementsAre(Usage{e, 1u}));
EXPECT_THAT(arg2->Usages(), testing::UnorderedElementsAre(Usage{e, 2u}));
@@ -39,7 +39,7 @@
{
Module mod;
Builder b{mod};
- b.UserCall(nullptr, b.CreateFunction("myfunc", mod.Types().void_()));
+ b.Call(nullptr, b.CreateFunction("myfunc", mod.Types().void_()));
},
"");
}
@@ -49,7 +49,7 @@
{
Module mod;
Builder b{mod};
- b.UserCall(mod.Types().f32(), nullptr);
+ b.Call(mod.Types().f32(), nullptr);
},
"");
}
@@ -59,8 +59,8 @@
{
Module mod;
Builder b{mod};
- b.UserCall(mod.Types().void_(), b.CreateFunction("myfunc", mod.Types().void_()),
- utils::Vector<Value*, 1>{nullptr});
+ b.Call(mod.Types().void_(), b.CreateFunction("myfunc", mod.Types().void_()),
+ utils::Vector<Value*, 1>{nullptr});
},
"");
}
diff --git a/src/tint/ir/validate.cc b/src/tint/ir/validate.cc
index e252212..19beb21 100644
--- a/src/tint/ir/validate.cc
+++ b/src/tint/ir/validate.cc
@@ -22,7 +22,7 @@
#include "src/tint/ir/binary.h"
#include "src/tint/ir/bitcast.h"
#include "src/tint/ir/break_if.h"
-#include "src/tint/ir/builtin.h"
+#include "src/tint/ir/builtin_call.h"
#include "src/tint/ir/construct.h"
#include "src/tint/ir/continue.h"
#include "src/tint/ir/convert.h"
@@ -181,16 +181,16 @@
void CheckInstruction(Instruction* inst) {
tint::Switch(
- inst, //
- [&](ir::Access* a) { CheckAccess(a); }, //
- [&](Binary*) {}, //
- [&](Branch* b) { CheckBranch(b); }, //
- [&](Call* c) { CheckCall(c); }, //
- [&](Load*) {}, //
- [&](Store*) {}, //
- [&](Swizzle*) {}, //
- [&](Unary*) {}, //
- [&](Var*) {}, //
+ inst, //
+ [&](Access* a) { CheckAccess(a); }, //
+ [&](Binary*) {}, //
+ [&](Branch* b) { CheckBranch(b); }, //
+ [&](Call* c) { CheckCall(c); }, //
+ [&](Load*) {}, //
+ [&](Store*) {}, //
+ [&](Swizzle*) {}, //
+ [&](Unary*) {}, //
+ [&](Var*) {}, //
[&](Default) {
AddError(std::string("missing validation of: ") + inst->TypeInfo().name);
});
@@ -198,13 +198,13 @@
void CheckCall(Call* call) {
tint::Switch(
- call, //
- [&](Bitcast*) {}, //
- [&](Builtin*) {}, //
- [&](Construct*) {}, //
- [&](Convert*) {}, //
- [&](Discard*) {}, //
- [&](UserCall*) {}, //
+ call, //
+ [&](Bitcast*) {}, //
+ [&](BuiltinCall*) {}, //
+ [&](Construct*) {}, //
+ [&](Convert*) {}, //
+ [&](Discard*) {}, //
+ [&](UserCall*) {}, //
[&](Default) {
AddError(std::string("missing validation of call: ") + call->TypeInfo().name);
});
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.cc b/src/tint/writer/spirv/ir/generator_impl_ir.cc
index c4a7161..ad1b180 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.cc
@@ -24,7 +24,7 @@
#include "src/tint/ir/block.h"
#include "src/tint/ir/block_param.h"
#include "src/tint/ir/break_if.h"
-#include "src/tint/ir/builtin.h"
+#include "src/tint/ir/builtin_call.h"
#include "src/tint/ir/continue.h"
#include "src/tint/ir/exit_if.h"
#include "src/tint/ir/exit_loop.h"
@@ -454,18 +454,18 @@
void GeneratorImplIr::EmitBlockInstructions(ir::Block* block) {
for (auto* inst : *block) {
Switch(
- inst, //
- [&](ir::Access* a) { EmitAccess(a); }, //
- [&](ir::Binary* b) { EmitBinary(b); }, //
- [&](ir::Builtin* b) { EmitBuiltin(b); }, //
- [&](ir::Load* l) { EmitLoad(l); }, //
- [&](ir::Loop* l) { EmitLoop(l); }, //
- [&](ir::Switch* sw) { EmitSwitch(sw); }, //
- [&](ir::Store* s) { EmitStore(s); }, //
- [&](ir::UserCall* c) { EmitUserCall(c); }, //
- [&](ir::Var* v) { EmitVar(v); }, //
- [&](ir::If* i) { EmitIf(i); }, //
- [&](ir::Branch* b) { EmitBranch(b); }, //
+ inst, //
+ [&](ir::Access* a) { EmitAccess(a); }, //
+ [&](ir::Binary* b) { EmitBinary(b); }, //
+ [&](ir::BuiltinCall* b) { EmitBuiltinCall(b); }, //
+ [&](ir::Load* l) { EmitLoad(l); }, //
+ [&](ir::Loop* l) { EmitLoop(l); }, //
+ [&](ir::Switch* sw) { EmitSwitch(sw); }, //
+ [&](ir::Store* s) { EmitStore(s); }, //
+ [&](ir::UserCall* c) { EmitUserCall(c); }, //
+ [&](ir::Var* v) { EmitVar(v); }, //
+ [&](ir::If* i) { EmitIf(i); }, //
+ [&](ir::Branch* b) { EmitBranch(b); }, //
[&](Default) {
TINT_ICE(Writer, diagnostics_)
<< "unimplemented instruction: " << inst->TypeInfo().name;
@@ -702,7 +702,7 @@
op, {Type(binary->Type()), id, Value(binary->LHS()), Value(binary->RHS())});
}
-void GeneratorImplIr::EmitBuiltin(ir::Builtin* builtin) {
+void GeneratorImplIr::EmitBuiltinCall(ir::BuiltinCall* builtin) {
auto* result_ty = builtin->Type();
if (builtin->Func() == builtin::Function::kAbs &&
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir.h b/src/tint/writer/spirv/ir/generator_impl_ir.h
index 06b51d3..dccb23a 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir.h
+++ b/src/tint/writer/spirv/ir/generator_impl_ir.h
@@ -34,7 +34,7 @@
class Block;
class BlockParam;
class Branch;
-class Builtin;
+class BuiltinCall;
class Function;
class If;
class Load;
@@ -144,7 +144,7 @@
/// Emit a builtin function call instruction.
/// @param call the builtin call instruction to emit
- void EmitBuiltin(ir::Builtin* call);
+ void EmitBuiltinCall(ir::BuiltinCall* call);
/// Emit a load instruction.
/// @param load the load instruction to emit
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc
index 65a06c1..5fe9f4b 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_builtin_test.cc
@@ -39,8 +39,8 @@
auto* func = b.CreateFunction("foo", ty.void_());
func->StartTarget()->SetInstructions(
- utils::Vector{b.Builtin(MakeScalarType(params.type), params.function,
- utils::Vector{MakeScalarValue(params.type)}),
+ utils::Vector{b.Call(MakeScalarType(params.type), params.function,
+ utils::Vector{MakeScalarValue(params.type)}),
b.Return(func)});
ASSERT_TRUE(IRIsValid()) << Error();
@@ -53,8 +53,8 @@
auto* func = b.CreateFunction("foo", ty.void_());
func->StartTarget()->SetInstructions(
- utils::Vector{b.Builtin(MakeVectorType(params.type), params.function,
- utils::Vector{MakeVectorValue(params.type)}),
+ utils::Vector{b.Call(MakeVectorType(params.type), params.function,
+ utils::Vector{MakeVectorValue(params.type)}),
b.Return(func)});
@@ -70,8 +70,8 @@
// Test that abs of an unsigned value just folds away.
TEST_F(SpvGeneratorImplTest, Builtin_Abs_u32) {
- auto* result = b.Builtin(MakeScalarType(kU32), builtin::Function::kAbs,
- utils::Vector{MakeScalarValue(kU32)});
+ auto* result =
+ b.Call(MakeScalarType(kU32), builtin::Function::kAbs, utils::Vector{MakeScalarValue(kU32)});
auto* func = b.CreateFunction("foo", MakeScalarType(kU32));
func->StartTarget()->SetInstructions(utils::Vector{result, b.Return(func, result)});
@@ -89,8 +89,8 @@
)");
}
TEST_F(SpvGeneratorImplTest, Builtin_Abs_vec2u) {
- auto* result = b.Builtin(MakeVectorType(kU32), builtin::Function::kAbs,
- utils::Vector{MakeVectorValue(kU32)});
+ auto* result =
+ b.Call(MakeVectorType(kU32), builtin::Function::kAbs, utils::Vector{MakeVectorValue(kU32)});
auto* func = b.CreateFunction("foo", MakeVectorType(kU32));
func->StartTarget()->SetInstructions(utils::Vector{result, b.Return(func, result)});
@@ -118,8 +118,8 @@
auto* func = b.CreateFunction("foo", ty.void_());
func->StartTarget()->SetInstructions(utils::Vector{
- b.Builtin(MakeScalarType(params.type), params.function,
- utils::Vector{MakeScalarValue(params.type), MakeScalarValue(params.type)}),
+ b.Call(MakeScalarType(params.type), params.function,
+ utils::Vector{MakeScalarValue(params.type), MakeScalarValue(params.type)}),
b.Return(func)});
ASSERT_TRUE(IRIsValid()) << Error();
@@ -132,8 +132,8 @@
auto* func = b.CreateFunction("foo", ty.void_());
func->StartTarget()->SetInstructions(utils::Vector{
- b.Builtin(MakeVectorType(params.type), params.function,
- utils::Vector{MakeVectorValue(params.type), MakeVectorValue(params.type)}),
+ b.Call(MakeVectorType(params.type), params.function,
+ utils::Vector{MakeVectorValue(params.type), MakeVectorValue(params.type)}),
b.Return(func)});
diff --git a/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc b/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
index ba71dd4..188f19e 100644
--- a/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
+++ b/src/tint/writer/spirv/ir/generator_impl_ir_function_test.cc
@@ -207,8 +207,7 @@
auto* bar = b.CreateFunction("bar", ty.void_());
bar->StartTarget()->SetInstructions(utils::Vector{
- b.UserCall(i32_ty, foo, utils::Vector{b.Constant(i32(2)), b.Constant(i32(3))}),
- b.Return(bar)});
+ b.Call(i32_ty, foo, utils::Vector{b.Constant(i32(2)), b.Constant(i32(3))}), b.Return(bar)});
ASSERT_TRUE(IRIsValid()) << Error();
@@ -243,7 +242,7 @@
auto* bar = b.CreateFunction("bar", ty.void_());
bar->StartTarget()->SetInstructions(
- utils::Vector{b.UserCall(ty.void_(), foo, utils::Empty), b.Return(bar)});
+ utils::Vector{b.Call(ty.void_(), foo, utils::Empty), b.Return(bar)});
ASSERT_TRUE(IRIsValid()) << Error();
