[tint][ir] Make type construction and conversion unsequenced

This allows them to be inlined in more places.

Change-Id: Id42e11bd48d862d210180ed1dc68403cc19711ec
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/153120
Reviewed-by: James Price <[email protected]>
Kokoro: Kokoro <[email protected]>

Author: ben-clayton

src/tint/lang/core/ir/builder.h

@@ -654,6 +654,15 @@ class Builder {
     /// @returns the instruction
     ir::Discard* Discard();
 
+    /// Creates a user function call instruction
+    /// @param func the function to call
+    /// @param args the call arguments
+    /// @returns the instruction
+    template <typename... ARGS>
+    ir::UserCall* Call(ir::Function* func, ARGS&&... args) {
+        return Call(func->ReturnType(), func, std::forward<ARGS>(args)...);
+    }
+
     /// Creates a user function call instruction
     /// @param type the return type of the call
     /// @param func the function to call
@@ -688,6 +697,15 @@ class Builder {
                                                     Values(std::forward<ARGS>(args)...)));
     }
 
+    /// Creates a value conversion instruction to the template type T
+    /// @param val the value to be converted
+    /// @returns the instruction
+    template <typename T, typename VAL>
+    ir::Convert* Convert(VAL&& val) {
+        auto* type = ir.Types().Get<T>();
+        return Convert(type, std::forward<VAL>(val));
+    }
+
     /// Creates a value conversion instruction
     /// @param to the type converted to
     /// @param val the value to be converted
@@ -698,6 +716,15 @@ class Builder {
                                                           Value(std::forward<VAL>(val))));
     }
 
+    /// Creates a value constructor instruction to the template type T
+    /// @param args the arguments to the constructor
+    /// @returns the instruction
+    template <typename T, typename... ARGS>
+    ir::Construct* Construct(ARGS&&... args) {
+        auto* type = ir.Types().Get<T>();
+        return Construct(type, std::forward<ARGS>(args)...);
+    }
+
     /// Creates a value constructor instruction
     /// @param type the type to constructed
     /// @param args the arguments to the constructor
@@ -768,6 +795,25 @@ class Builder {
     /// @returns the instruction
     ir::Var* Var(std::string_view name, const core::type::Pointer* type);
 
+    /// Creates a new `var` declaration with a name and initializer value
+    /// @param name the var name
+    /// @param init the var initializer
+    /// @returns the instruction
+    template <core::AddressSpace SPACE = core::AddressSpace::kFunction,
+              core::Access ACCESS = core::Access::kReadWrite,
+              typename VALUE = void>
+    ir::Var* Var(std::string_view name, VALUE&& init) {
+        auto* val = Value(std::forward<VALUE>(init));
+        if (TINT_UNLIKELY(!val)) {
+            TINT_ASSERT(val);
+            return nullptr;
+        }
+        auto* var = Var(name, ir.Types().ptr(SPACE, val->Type(), ACCESS));
+        var->SetInitializer(val);
+        ir.SetName(var->Result(), name);
+        return var;
+    }
+
     /// Creates a new `let` declaration
     /// @param name the let name
     /// @param value the let value

src/tint/lang/core/ir/builtin_call.cc

@@ -21,6 +21,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::core::ir::BuiltinCall);
 namespace tint::core::ir {
 
 BuiltinCall::BuiltinCall(InstructionResult* result, VectorRef<Value*> arguments) {
+    flags_.Add(Flag::kSequenced);
     AddOperands(BuiltinCall::kArgsOperandOffset, std::move(arguments));
     AddResult(result);
 }

src/tint/lang/core/ir/call.cc

@@ -20,9 +20,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::core::ir::Call);
 
 namespace tint::core::ir {
 
-Call::Call() {
-    flags_.Add(Flag::kSequenced);
-}
+Call::Call() = default;
 
 Call::~Call() = default;
 

src/tint/lang/core/ir/core_builtin_call_test.cc

@@ -48,7 +48,7 @@ TEST_F(IR_CoreBuiltinCallTest, Fail_NullType) {
         {
             Module mod;
             Builder b{mod};
-            b.Call(nullptr, core::BuiltinFn::kAbs);
+            b.Call(static_cast<type::Type*>(nullptr), core::BuiltinFn::kAbs);
         },
         "");
 }

src/tint/lang/core/ir/discard.cc

@@ -21,7 +21,9 @@ TINT_INSTANTIATE_TYPEINFO(tint::core::ir::Discard);
 
 namespace tint::core::ir {
 
-Discard::Discard() = default;
+Discard::Discard() {
+    flags_.Add(Flag::kSequenced);
+}
 
 Discard::~Discard() = default;
 

src/tint/lang/core/ir/user_call.cc

@@ -24,6 +24,7 @@ TINT_INSTANTIATE_TYPEINFO(tint::core::ir::UserCall);
 namespace tint::core::ir {
 
 UserCall::UserCall(InstructionResult* result, Function* func, VectorRef<Value*> arguments) {
+    flags_.Add(Flag::kSequenced);
     AddOperand(UserCall::kFunctionOperandOffset, func);
     AddOperands(UserCall::kArgsOperandOffset, std::move(arguments));
     AddResult(result);

src/tint/lang/core/ir/user_call_test.cc

@@ -51,7 +51,7 @@ TEST_F(IR_UserCallTest, Fail_NullType) {
         {
             Module mod;
             Builder b{mod};
-            b.Call(nullptr, b.Function("myfunc", mod.Types().void_()));
+            b.Call(static_cast<type::Type*>(nullptr), b.Function("myfunc", mod.Types().void_()));
         },
         "");
 }

src/tint/lang/wgsl/writer/ir_to_program/inlining_test.cc

@@ -735,9 +735,8 @@ fn a(v : i32) -> i32 {
 }
 
 fn f() -> f32 {
-  let v_1 = array<mat3x4<f32>, 5u>();
-  let v_2 = a(2i);
-  return v_1[a(1i)][v_2][a(3i)];
+  let v_1 = a(2i);
+  return array<mat3x4<f32>, 5u>()[a(1i)][v_1][a(3i)];
 }
 )");
 }
@@ -763,9 +762,8 @@ fn a(v : i32) -> i32 {
 }
 
 fn f() -> f32 {
-  let v_1 = array<mat3x4<f32>, 5u>();
-  let v_2 = a(3i);
-  return v_1[a(1i)][a(2i)][v_2];
+  let v_1 = a(3i);
+  return array<mat3x4<f32>, 5u>()[a(1i)][a(2i)][v_1];
 }
 )");
 }
@@ -791,10 +789,9 @@ fn a(v : i32) -> i32 {
 }
 
 fn f() -> f32 {
-  let v_1 = array<mat3x4<f32>, 5u>();
-  let v_2 = a(3i);
-  let v_3 = a(2i);
-  return v_1[a(1i)][v_3][v_2];
+  let v_1 = a(3i);
+  let v_2 = a(2i);
+  return array<mat3x4<f32>, 5u>()[a(1i)][v_2][v_1];
 }
 )");
 }