From 9328d94572c530a86427e76fbf430ab81e2e2571 Mon Sep 17 00:00:00 2001 From: Ben Clayton Date: Thu, 8 Apr 2021 14:39:47 +0000 Subject: [PATCH] wgsl: Deprecate '-> void' on functions Was removed with: https://github.com/gpuweb/gpuweb/pull/1460 Bug: tint:677 Change-Id: If08cb450189c6158561051ef6e8f2439c60bc010 Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/47140 Auto-Submit: Ben Clayton Kokoro: Kokoro Reviewed-by: David Neto Commit-Queue: Ben Clayton --- src/ast/intrinsic_texture_helper_test.cc | 8 +- src/ast/module_clone_test.cc | 4 +- src/diagnostic/diagnostic.h | 11 + src/reader/wgsl/parser_impl.cc | 63 +- src/reader/wgsl/parser_impl.h | 6 +- src/reader/wgsl/parser_impl_body_stmt_test.cc | 2 +- src/reader/wgsl/parser_impl_else_stmt_test.cc | 2 +- .../wgsl/parser_impl_elseif_stmt_test.cc | 2 +- src/reader/wgsl/parser_impl_error_msg_test.cc | 606 +++++++++--------- .../wgsl/parser_impl_error_resync_test.cc | 20 +- src/reader/wgsl/parser_impl_for_stmt_test.cc | 2 +- .../wgsl/parser_impl_function_decl_test.cc | 16 +- .../wgsl/parser_impl_function_header_test.cc | 26 +- .../wgsl/parser_impl_global_decl_test.cc | 4 +- src/reader/wgsl/parser_impl_if_stmt_test.cc | 2 +- .../wgsl/parser_impl_switch_body_test.cc | 4 +- src/reader/wgsl/parser_impl_test.cc | 2 +- src/reader/wgsl/parser_test.cc | 2 +- src/resolver/function_validation_test.cc | 14 +- src/resolver/resolver_test.cc | 6 +- .../type_constructor_validation_test.cc | 2 +- src/resolver/type_validation_test.cc | 8 +- src/resolver/validation_test.cc | 10 +- src/transform/binding_remapper_test.cc | 20 +- src/transform/bound_array_accessors_test.cc | 84 +-- .../canonicalize_entry_point_io_test.cc | 28 +- src/transform/emit_vertex_point_size_test.cc | 32 +- src/transform/first_index_offset_test.cc | 18 +- src/transform/hlsl_test.cc | 28 +- src/transform/msl_test.cc | 8 +- src/transform/renamer_test.cc | 4 +- src/transform/spirv.cc | 8 +- src/transform/spirv_test.cc | 74 +-- src/transform/vertex_pulling_test.cc | 32 +- .../hlsl/generator_impl_function_test.cc | 6 +- .../msl/generator_impl_function_test.cc | 6 +- src/writer/spirv/builder_entry_point_test.cc | 2 +- src/writer/spirv/builder_function_test.cc | 4 +- .../spirv/builder_global_variable_test.cc | 4 +- src/writer/wgsl/generator_impl.cc | 21 +- .../wgsl/generator_impl_entry_point_test.cc | 8 +- .../wgsl/generator_impl_function_test.cc | 20 +- .../wgsl/generator_impl_global_decl_test.cc | 4 +- src/writer/wgsl/generator_impl_test.cc | 2 +- test/compute_boids.wgsl | 2 +- test/function.wgsl | 2 +- test/simple.wgsl | 2 +- tools/check-spec-examples/main.go | 4 +- 48 files changed, 645 insertions(+), 600 deletions(-) diff --git a/src/ast/intrinsic_texture_helper_test.cc b/src/ast/intrinsic_texture_helper_test.cc index 894858a05a..0d9632e82b 100644 --- a/src/ast/intrinsic_texture_helper_test.cc +++ b/src/ast/intrinsic_texture_helper_test.cc @@ -2244,7 +2244,7 @@ std::vector TextureOverloadCase::ValidCases() { ValidTextureOverload::kStoreWO1dRgba32float, "textureStore(t : texture_storage_1d,\n" " coords : i32,\n" - " value : vec4) -> void", + " value : vec4)", ast::AccessControl::kWriteOnly, type::ImageFormat::kRgba32Float, type::TextureDimension::k1d, @@ -2260,7 +2260,7 @@ std::vector TextureOverloadCase::ValidCases() { ValidTextureOverload::kStoreWO2dRgba32float, "textureStore(t : texture_storage_2d,\n" " coords : vec2,\n" - " value : vec4) -> void", + " value : vec4)", ast::AccessControl::kWriteOnly, type::ImageFormat::kRgba32Float, type::TextureDimension::k2d, @@ -2277,7 +2277,7 @@ std::vector TextureOverloadCase::ValidCases() { "textureStore(t : texture_storage_2d_array,\n" " coords : vec2,\n" " array_index : i32,\n" - " value : vec4) -> void", + " value : vec4)", ast::AccessControl::kWriteOnly, type::ImageFormat::kRgba32Float, type::TextureDimension::k2dArray, @@ -2294,7 +2294,7 @@ std::vector TextureOverloadCase::ValidCases() { ValidTextureOverload::kStoreWO3dRgba32float, "textureStore(t : texture_storage_3d,\n" " coords : vec3,\n" - " value : vec4) -> void", + " value : vec4)", ast::AccessControl::kWriteOnly, type::ImageFormat::kRgba32Float, type::TextureDimension::k3d, diff --git a/src/ast/module_clone_test.cc b/src/ast/module_clone_test.cc index 1fc36c189a..9f741de2d4 100644 --- a/src/ast/module_clone_test.cc +++ b/src/ast/module_clone_test.cc @@ -98,7 +98,7 @@ fn f1(p0 : f32, p1 : i32) -> f32 { } [[stage(fragment)]] -fn main() -> void { +fn main() { f1(1.0, 2); } @@ -106,7 +106,7 @@ const declaration_order_check_0 : i32 = 1; type declaration_order_check_1 = f32; -fn declaration_order_check_2() -> void {} +fn declaration_order_check_2() {} type declaration_order_check_2 = f32; diff --git a/src/diagnostic/diagnostic.h b/src/diagnostic/diagnostic.h index 4b0c824913..0c6847f4fb 100644 --- a/src/diagnostic/diagnostic.h +++ b/src/diagnostic/diagnostic.h @@ -108,6 +108,17 @@ class List { add(std::move(error)); } + /// adds the warning message with the given Source to the end of this list. + /// @param warning_msg the warning message + /// @param source the source of the warning diagnostic + void add_warning(const std::string& warning_msg, const Source& source) { + diag::Diagnostic error{}; + error.severity = diag::Severity::Warning; + error.source = source; + error.message = warning_msg; + add(std::move(error)); + } + /// adds the error message without a source to the end of this list. /// @param err_msg the error message void add_error(std::string err_msg) { diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc index 25094bfab9..6eda22cba9 100644 --- a/src/reader/wgsl/parser_impl.cc +++ b/src/reader/wgsl/parser_impl.cc @@ -211,6 +211,11 @@ ParserImpl::Failure::Errored ParserImpl::add_error(const Source& source, return Failure::kErrored; } +void ParserImpl::deprecated(const Source& source, const std::string& msg) { + builder_.Diagnostics().add_warning( + "use of deprecated language feature: " + msg, source); +} + Token ParserImpl::next() { if (!token_queue_.empty()) { auto t = token_queue_.front(); @@ -1207,8 +1212,9 @@ Maybe ParserImpl::function_type_decl() { // : FN IDENT PAREN_LEFT param_list PAREN_RIGHT ARROW function_type_decl Maybe ParserImpl::function_header() { Source source; - if (!match(Token::Type::kFn, &source)) + if (!match(Token::Type::kFn, &source)) { return Failure::kNoMatch; + } const char* use = "function declaration"; bool errored = false; @@ -1216,37 +1222,56 @@ Maybe ParserImpl::function_header() { auto name = expect_ident(use); if (name.errored) { errored = true; - if (!sync_to(Token::Type::kParenLeft, /* consume: */ false)) + if (!sync_to(Token::Type::kParenLeft, /* consume: */ false)) { return Failure::kErrored; + } } auto params = expect_paren_block(use, [&] { return expect_param_list(); }); if (params.errored) { errored = true; - if (!synchronized_) + if (!synchronized_) { return Failure::kErrored; + } } - if (!expect(use, Token::Type::kArrow)) - return Failure::kErrored; + type::Type* return_type = nullptr; + ast::DecorationList return_decorations; - auto decos = decoration_list(); - if (decos.errored) { + if (match(Token::Type::kArrow)) { + auto decos = decoration_list(); + if (decos.errored) { + return Failure::kErrored; + } + return_decorations = decos.value; + + auto tok = peek(); + + auto type = function_type_decl(); + if (type.errored) { + errored = true; + } else if (!type.matched) { + return add_error(peek(), "unable to determine function return type"); + } else { + return_type = type.value; + } + + if (return_type->Is()) { + // crbug.com/tint/677: void has been removed from the language + deprecated(tok.source(), + "omit '-> void' for functions that do not return a value"); + } + + } else { + return_type = builder_.ty.void_(); + } + + if (errored) { return Failure::kErrored; } - auto type = function_type_decl(); - if (type.errored) { - errored = true; - } else if (!type.matched) { - return add_error(peek(), "unable to determine function return type"); - } - - if (errored) - return Failure::kErrored; - - return FunctionHeader{source, name.value, std::move(params.value), type.value, - std::move(decos.value)}; + return FunctionHeader{source, name.value, std::move(params.value), + return_type, std::move(return_decorations)}; } // param_list diff --git a/src/reader/wgsl/parser_impl.h b/src/reader/wgsl/parser_impl.h index c048a3e202..7f4929b96a 100644 --- a/src/reader/wgsl/parser_impl.h +++ b/src/reader/wgsl/parser_impl.h @@ -320,7 +320,11 @@ class ParserImpl { /// @return `Failure::Errored::kError` so that you can combine an add_error() /// call and return on the same line. Failure::Errored add_error(const Source& source, const std::string& msg); - + /// Appends a deprecated-language-feature warning at `source` with the message + /// `msg` + /// @param source the source to associate the error with + /// @param msg the warning message + void deprecated(const Source& source, const std::string& msg); /// Registers a constructed type into the parser /// @param name the constructed name /// @param type the constructed type diff --git a/src/reader/wgsl/parser_impl_body_stmt_test.cc b/src/reader/wgsl/parser_impl_body_stmt_test.cc index 29acc7fcf0..73468e95b4 100644 --- a/src/reader/wgsl/parser_impl_body_stmt_test.cc +++ b/src/reader/wgsl/parser_impl_body_stmt_test.cc @@ -42,7 +42,7 @@ TEST_F(ParserImplTest, BodyStmt_Empty) { } TEST_F(ParserImplTest, BodyStmt_InvalidStmt) { - auto p = parser("{fn main() -> void {}}"); + auto p = parser("{fn main() {}}"); auto e = p->expect_body_stmt(); ASSERT_TRUE(p->has_error()); ASSERT_TRUE(e.errored); diff --git a/src/reader/wgsl/parser_impl_else_stmt_test.cc b/src/reader/wgsl/parser_impl_else_stmt_test.cc index bd883fd061..4d2f87ba40 100644 --- a/src/reader/wgsl/parser_impl_else_stmt_test.cc +++ b/src/reader/wgsl/parser_impl_else_stmt_test.cc @@ -32,7 +32,7 @@ TEST_F(ParserImplTest, ElseStmt) { } TEST_F(ParserImplTest, ElseStmt_InvalidBody) { - auto p = parser("else { fn main() -> void {}}"); + auto p = parser("else { fn main() {}}"); auto e = p->else_stmt(); EXPECT_FALSE(e.matched); EXPECT_TRUE(e.errored); diff --git a/src/reader/wgsl/parser_impl_elseif_stmt_test.cc b/src/reader/wgsl/parser_impl_elseif_stmt_test.cc index 15dab84f40..7051f47025 100644 --- a/src/reader/wgsl/parser_impl_elseif_stmt_test.cc +++ b/src/reader/wgsl/parser_impl_elseif_stmt_test.cc @@ -53,7 +53,7 @@ TEST_F(ParserImplTest, ElseIfStmt_Multiple) { } TEST_F(ParserImplTest, ElseIfStmt_InvalidBody) { - auto p = parser("elseif (true) { fn main() -> void {}}"); + auto p = parser("elseif (true) { fn main() {}}"); auto e = p->elseif_stmt(); EXPECT_FALSE(e.matched); EXPECT_TRUE(e.errored); diff --git a/src/reader/wgsl/parser_impl_error_msg_test.cc b/src/reader/wgsl/parser_impl_error_msg_test.cc index 4dd48712ca..58f5b82657 100644 --- a/src/reader/wgsl/parser_impl_error_msg_test.cc +++ b/src/reader/wgsl/parser_impl_error_msg_test.cc @@ -38,179 +38,179 @@ class ParserImplErrorTest : public ParserImplTest {}; } while (false) TEST_F(ParserImplErrorTest, AdditiveInvalidExpr) { - EXPECT("fn f() -> void { return 1.0 + <; }", - "test.wgsl:1:31 error: unable to parse right side of + expression\n" - "fn f() -> void { return 1.0 + <; }\n" - " ^\n"); + EXPECT("fn f() { return 1.0 + <; }", + "test.wgsl:1:23 error: unable to parse right side of + expression\n" + "fn f() { return 1.0 + <; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, AndInvalidExpr) { - EXPECT("fn f() -> void { return 1 & >; }", - "test.wgsl:1:29 error: unable to parse right side of & expression\n" - "fn f() -> void { return 1 & >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 & >; }", + "test.wgsl:1:21 error: unable to parse right side of & expression\n" + "fn f() { return 1 & >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ArrayIndexExprInvalidExpr) { - EXPECT("fn f() -> void { x = y[^]; }", - "test.wgsl:1:24 error: unable to parse expression inside []\n" - "fn f() -> void { x = y[^]; }\n" - " ^\n"); + EXPECT("fn f() { x = y[^]; }", + "test.wgsl:1:16 error: unable to parse expression inside []\n" + "fn f() { x = y[^]; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ArrayIndexExprMissingRBracket) { - EXPECT("fn f() -> void { x = y[1; }", - "test.wgsl:1:25 error: expected ']' for array accessor\n" - "fn f() -> void { x = y[1; }\n" - " ^\n"); + EXPECT("fn f() { x = y[1; }", + "test.wgsl:1:17 error: expected ']' for array accessor\n" + "fn f() { x = y[1; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, AssignmentStmtMissingAssignment) { - EXPECT("fn f() -> void { a; }", - "test.wgsl:1:19 error: expected '=' for assignment\n" - "fn f() -> void { a; }\n" - " ^\n"); + EXPECT("fn f() { a; }", + "test.wgsl:1:11 error: expected '=' for assignment\n" + "fn f() { a; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, AssignmentStmtMissingAssignment2) { - EXPECT("fn f() -> void { a : i32; }", - "test.wgsl:1:18 error: expected 'var' for variable declaration\n" - "fn f() -> void { a : i32; }\n" - " ^\n"); + EXPECT("fn f() { a : i32; }", + "test.wgsl:1:10 error: expected 'var' for variable declaration\n" + "fn f() { a : i32; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, AssignmentStmtMissingSemicolon) { - EXPECT("fn f() -> void { a = 1 }", - "test.wgsl:1:24 error: expected ';' for assignment statement\n" - "fn f() -> void { a = 1 }\n" - " ^\n"); + EXPECT("fn f() { a = 1 }", + "test.wgsl:1:16 error: expected ';' for assignment statement\n" + "fn f() { a = 1 }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, AssignmentStmtInvalidRHS) { - EXPECT("fn f() -> void { a = >; }", - "test.wgsl:1:22 error: unable to parse right side of assignment\n" - "fn f() -> void { a = >; }\n" - " ^\n"); + EXPECT("fn f() { a = >; }", + "test.wgsl:1:14 error: unable to parse right side of assignment\n" + "fn f() { a = >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, BitcastExprMissingLessThan) { - EXPECT("fn f() -> void { x = bitcast(y); }", - "test.wgsl:1:29 error: expected '<' for bitcast expression\n" - "fn f() -> void { x = bitcast(y); }\n" - " ^\n"); + EXPECT("fn f() { x = bitcast(y); }", + "test.wgsl:1:21 error: expected '<' for bitcast expression\n" + "fn f() { x = bitcast(y); }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, BitcastExprMissingGreaterThan) { - EXPECT("fn f() -> void { x = bitcast' for bitcast expression\n" - "fn f() -> void { x = bitcast' for bitcast expression\n" + "fn f() { x = bitcast void { x = bitcast<>(y); }", - "test.wgsl:1:30 error: invalid type for bitcast expression\n" - "fn f() -> void { x = bitcast<>(y); }\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, BreakStmtMissingSemicolon) { - EXPECT("fn f() -> void { loop { break } }", - "test.wgsl:1:31 error: expected ';' for break statement\n" - "fn f() -> void { loop { break } }\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, CallExprMissingRParen) { - EXPECT("fn f() -> void { x = f(1.; }", - "test.wgsl:1:26 error: expected ')' for call expression\n" - "fn f() -> void { x = f(1.; }\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, CallStmtMissingRParen) { - EXPECT("fn f() -> void { f(1.; }", - "test.wgsl:1:22 error: expected ')' for call statement\n" - "fn f() -> void { f(1.; }\n" + EXPECT("fn f() { x = bitcast<>(y); }", + "test.wgsl:1:22 error: invalid type for bitcast expression\n" + "fn f() { x = bitcast<>(y); }\n" " ^\n"); } +TEST_F(ParserImplErrorTest, BreakStmtMissingSemicolon) { + EXPECT("fn f() { loop { break } }", + "test.wgsl:1:23 error: expected ';' for break statement\n" + "fn f() { loop { break } }\n" + " ^\n"); +} + +TEST_F(ParserImplErrorTest, CallExprMissingRParen) { + EXPECT("fn f() { x = f(1.; }", + "test.wgsl:1:18 error: expected ')' for call expression\n" + "fn f() { x = f(1.; }\n" + " ^\n"); +} + +TEST_F(ParserImplErrorTest, CallStmtMissingRParen) { + EXPECT("fn f() { f(1.; }", + "test.wgsl:1:14 error: expected ')' for call statement\n" + "fn f() { f(1.; }\n" + " ^\n"); +} + TEST_F(ParserImplErrorTest, CallStmtInvalidArgument0) { - EXPECT("fn f() -> void { f(<); }", - "test.wgsl:1:20 error: unable to parse argument expression\n" - "fn f() -> void { f(<); }\n" - " ^\n"); + EXPECT("fn f() { f(<); }", + "test.wgsl:1:12 error: unable to parse argument expression\n" + "fn f() { f(<); }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, CallStmtInvalidArgument1) { EXPECT( - "fn f() -> void { f(1.0, <); }", - "test.wgsl:1:25 error: unable to parse argument expression after comma\n" - "fn f() -> void { f(1.0, <); }\n" - " ^\n"); + "fn f() { f(1.0, <); }", + "test.wgsl:1:17 error: unable to parse argument expression after comma\n" + "fn f() { f(1.0, <); }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, CallStmtMissingSemicolon) { - EXPECT("fn f() -> void { f() }", - "test.wgsl:1:22 error: expected ';' for function call\n" - "fn f() -> void { f() }\n" - " ^\n"); + EXPECT("fn f() { f() }", + "test.wgsl:1:14 error: expected ';' for function call\n" + "fn f() { f() }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ConstructorExprMissingLParen) { - EXPECT("fn f() -> void { x = vec21,2); }", - "test.wgsl:1:31 error: expected '(' for type constructor\n" - "fn f() -> void { x = vec21,2); }\n" - " ^\n"); + EXPECT("fn f() { x = vec21,2); }", + "test.wgsl:1:23 error: expected '(' for type constructor\n" + "fn f() { x = vec21,2); }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ConstructorExprMissingRParen) { - EXPECT("fn f() -> void { x = vec2(1,2; }", - "test.wgsl:1:35 error: expected ')' for type constructor\n" - "fn f() -> void { x = vec2(1,2; }\n" - " ^\n"); + EXPECT("fn f() { x = vec2(1,2; }", + "test.wgsl:1:27 error: expected ')' for type constructor\n" + "fn f() { x = vec2(1,2; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ConstVarStmtInvalid) { - EXPECT("fn f() -> void { const >; }", - "test.wgsl:1:24 error: expected identifier for constant declaration\n" - "fn f() -> void { const >; }\n" - " ^\n"); + EXPECT("fn f() { const >; }", + "test.wgsl:1:16 error: expected identifier for constant declaration\n" + "fn f() { const >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ConstVarStmtMissingAssignment) { - EXPECT("fn f() -> void { const a : i32; }", - "test.wgsl:1:31 error: expected '=' for constant declaration\n" - "fn f() -> void { const a : i32; }\n" - " ^\n"); + EXPECT("fn f() { const a : i32; }", + "test.wgsl:1:23 error: expected '=' for constant declaration\n" + "fn f() { const a : i32; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ConstVarStmtMissingConstructor) { - EXPECT("fn f() -> void { const a : i32 = >; }", - "test.wgsl:1:34 error: missing constructor for const declaration\n" - "fn f() -> void { const a : i32 = >; }\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, ContinueStmtMissingSemicolon) { - EXPECT("fn f() -> void { loop { continue } }", - "test.wgsl:1:34 error: expected ';' for continue statement\n" - "fn f() -> void { loop { continue } }\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, DiscardStmtMissingSemicolon) { - EXPECT("fn f() -> void { discard }", - "test.wgsl:1:26 error: expected ';' for discard statement\n" - "fn f() -> void { discard }\n" + EXPECT("fn f() { const a : i32 = >; }", + "test.wgsl:1:26 error: missing constructor for const declaration\n" + "fn f() { const a : i32 = >; }\n" " ^\n"); } +TEST_F(ParserImplErrorTest, ContinueStmtMissingSemicolon) { + EXPECT("fn f() { loop { continue } }", + "test.wgsl:1:26 error: expected ';' for continue statement\n" + "fn f() { loop { continue } }\n" + " ^\n"); +} + +TEST_F(ParserImplErrorTest, DiscardStmtMissingSemicolon) { + EXPECT("fn f() { discard }", + "test.wgsl:1:18 error: expected ';' for discard statement\n" + "fn f() { discard }\n" + " ^\n"); +} + TEST_F(ParserImplErrorTest, EqualityInvalidExpr) { - EXPECT("fn f() -> void { return 1 == >; }", - "test.wgsl:1:30 error: unable to parse right side of == expression\n" - "fn f() -> void { return 1 == >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 == >; }", + "test.wgsl:1:22 error: unable to parse right side of == expression\n" + "fn f() { return 1 == >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, FloatLiteralSuffixedWithF) { @@ -221,52 +221,52 @@ TEST_F(ParserImplErrorTest, FloatLiteralSuffixedWithF) { } TEST_F(ParserImplErrorTest, ForLoopInitializerMissingSemicolon) { - EXPECT("fn f() -> void { for (var i : i32 = 0 i < 8; i=i+1) {} }", - "test.wgsl:1:39 error: expected ';' for initializer in for loop\n" - "fn f() -> void { for (var i : i32 = 0 i < 8; i=i+1) {} }\n" - " ^\n"); + EXPECT("fn f() { for (var i : i32 = 0 i < 8; i=i+1) {} }", + "test.wgsl:1:31 error: expected ';' for initializer in for loop\n" + "fn f() { for (var i : i32 = 0 i < 8; i=i+1) {} }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ForLoopInitializerMissingVar) { - EXPECT("fn f() -> void { for (i : i32 = 0; i < 8; i=i+1) {} }", - "test.wgsl:1:23 error: expected 'var' for variable declaration\n" - "fn f() -> void { for (i : i32 = 0; i < 8; i=i+1) {} }\n" - " ^\n"); + EXPECT("fn f() { for (i : i32 = 0; i < 8; i=i+1) {} }", + "test.wgsl:1:15 error: expected 'var' for variable declaration\n" + "fn f() { for (i : i32 = 0; i < 8; i=i+1) {} }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ForLoopConditionMissingSemicolon) { - EXPECT("fn f() -> void { for (var i : i32 = 0; i < 8 i=i+1) {} }", - "test.wgsl:1:46 error: expected ';' for condition in for loop\n" - "fn f() -> void { for (var i : i32 = 0; i < 8 i=i+1) {} }\n" - " ^\n"); + EXPECT("fn f() { for (var i : i32 = 0; i < 8 i=i+1) {} }", + "test.wgsl:1:38 error: expected ';' for condition in for loop\n" + "fn f() { for (var i : i32 = 0; i < 8 i=i+1) {} }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ForLoopMissingLParen) { - EXPECT("fn f() -> void { for var i : i32 = 0; i < 8; i=i+1) {} }", - "test.wgsl:1:22 error: expected '(' for for loop\n" - "fn f() -> void { for var i : i32 = 0; i < 8; i=i+1) {} }\n" - " ^^^\n"); + EXPECT("fn f() { for var i : i32 = 0; i < 8; i=i+1) {} }", + "test.wgsl:1:14 error: expected '(' for for loop\n" + "fn f() { for var i : i32 = 0; i < 8; i=i+1) {} }\n" + " ^^^\n"); } TEST_F(ParserImplErrorTest, ForLoopMissingRParen) { - EXPECT("fn f() -> void { for (var i : i32 = 0; i < 8; i=i+1 {} }", - "test.wgsl:1:53 error: expected ')' for for loop\n" - "fn f() -> void { for (var i : i32 = 0; i < 8; i=i+1 {} }\n" - " ^\n"); + EXPECT("fn f() { for (var i : i32 = 0; i < 8; i=i+1 {} }", + "test.wgsl:1:45 error: expected ')' for for loop\n" + "fn f() { for (var i : i32 = 0; i < 8; i=i+1 {} }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ForLoopMissingLBrace) { - EXPECT("fn f() -> void { for (var i : i32 = 0; i < 8; i=i+1) }", - "test.wgsl:1:54 error: expected '{' for for loop\n" - "fn f() -> void { for (var i : i32 = 0; i < 8; i=i+1) }\n" - " ^\n"); + EXPECT("fn f() { for (var i : i32 = 0; i < 8; i=i+1) }", + "test.wgsl:1:46 error: expected '{' for for loop\n" + "fn f() { for (var i : i32 = 0; i < 8; i=i+1) }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ForLoopMissingRBrace) { - EXPECT("fn f() -> void { for (var i : i32 = 0; i < 8; i=i+1) {", - "test.wgsl:1:55 error: expected '}' for for loop\n" - "fn f() -> void { for (var i : i32 = 0; i < 8; i=i+1) {\n" - " ^\n"); + EXPECT("fn f() { for (var i : i32 = 0; i < 8; i=i+1) {", + "test.wgsl:1:47 error: expected '}' for for loop\n" + "fn f() { for (var i : i32 = 0; i < 8; i=i+1) {\n" + " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclInvalid) { @@ -277,150 +277,150 @@ TEST_F(ParserImplErrorTest, FunctionDeclInvalid) { } TEST_F(ParserImplErrorTest, FunctionDeclDecoMissingEnd) { - EXPECT("[[stage(vertex) fn f() -> void {}", + EXPECT("[[stage(vertex) fn f() {}", "test.wgsl:1:17 error: expected ']]' for decoration list\n" - "[[stage(vertex) fn f() -> void {}\n" + "[[stage(vertex) fn f() {}\n" " ^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoStageMissingLParen) { - EXPECT("[[stage vertex]] fn f() -> void {}", + EXPECT("[[stage vertex]] fn f() {}", "test.wgsl:1:9 error: expected '(' for stage decoration\n" - "[[stage vertex]] fn f() -> void {}\n" + "[[stage vertex]] fn f() {}\n" " ^^^^^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoStageMissingRParen) { - EXPECT("[[stage(vertex]] fn f() -> void {}", + EXPECT("[[stage(vertex]] fn f() {}", "test.wgsl:1:15 error: expected ')' for stage decoration\n" - "[[stage(vertex]] fn f() -> void {}\n" + "[[stage(vertex]] fn f() {}\n" " ^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoStageInvalid) { - EXPECT("[[stage(x)]] fn f() -> void {}", + EXPECT("[[stage(x)]] fn f() {}", "test.wgsl:1:9 error: invalid value for stage decoration\n" - "[[stage(x)]] fn f() -> void {}\n" + "[[stage(x)]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoStageTypeInvalid) { - EXPECT("[[shader(vertex)]] fn main() -> void {}", + EXPECT("[[shader(vertex)]] fn main() {}", "test.wgsl:1:3 error: expected decoration\n" - "[[shader(vertex)]] fn main() -> void {}\n" + "[[shader(vertex)]] fn main() {}\n" " ^^^^^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeMissingLParen) { - EXPECT("[[workgroup_size 1]] fn f() -> void {}", + EXPECT("[[workgroup_size 1]] fn f() {}", "test.wgsl:1:18 error: expected '(' for workgroup_size decoration\n" - "[[workgroup_size 1]] fn f() -> void {}\n" + "[[workgroup_size 1]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeMissingRParen) { - EXPECT("[[workgroup_size(1]] fn f() -> void {}", + EXPECT("[[workgroup_size(1]] fn f() {}", "test.wgsl:1:19 error: expected ')' for workgroup_size decoration\n" - "[[workgroup_size(1]] fn f() -> void {}\n" + "[[workgroup_size(1]] fn f() {}\n" " ^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeXInvalid) { - EXPECT("[[workgroup_size(x)]] fn f() -> void {}", + EXPECT("[[workgroup_size(x)]] fn f() {}", "test.wgsl:1:18 error: expected signed integer literal for " "workgroup_size x parameter\n" - "[[workgroup_size(x)]] fn f() -> void {}\n" + "[[workgroup_size(x)]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeXNegative) { - EXPECT("[[workgroup_size(-1)]] fn f() -> void {}", + EXPECT("[[workgroup_size(-1)]] fn f() {}", "test.wgsl:1:18 error: workgroup_size x parameter must be greater " "than 0\n" - "[[workgroup_size(-1)]] fn f() -> void {}\n" + "[[workgroup_size(-1)]] fn f() {}\n" " ^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeXZero) { - EXPECT("[[workgroup_size(0)]] fn f() -> void {}", + EXPECT("[[workgroup_size(0)]] fn f() {}", "test.wgsl:1:18 error: workgroup_size x parameter must be greater " "than 0\n" - "[[workgroup_size(0)]] fn f() -> void {}\n" + "[[workgroup_size(0)]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeYInvalid) { - EXPECT("[[workgroup_size(1, x)]] fn f() -> void {}", + EXPECT("[[workgroup_size(1, x)]] fn f() {}", "test.wgsl:1:21 error: expected signed integer literal for " "workgroup_size y parameter\n" - "[[workgroup_size(1, x)]] fn f() -> void {}\n" + "[[workgroup_size(1, x)]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeYNegative) { - EXPECT("[[workgroup_size(1, -1)]] fn f() -> void {}", + EXPECT("[[workgroup_size(1, -1)]] fn f() {}", "test.wgsl:1:21 error: workgroup_size y parameter must be greater " "than 0\n" - "[[workgroup_size(1, -1)]] fn f() -> void {}\n" + "[[workgroup_size(1, -1)]] fn f() {}\n" " ^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeYZero) { - EXPECT("[[workgroup_size(1, 0)]] fn f() -> void {}", + EXPECT("[[workgroup_size(1, 0)]] fn f() {}", "test.wgsl:1:21 error: workgroup_size y parameter must be greater " "than 0\n" - "[[workgroup_size(1, 0)]] fn f() -> void {}\n" + "[[workgroup_size(1, 0)]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeZInvalid) { - EXPECT("[[workgroup_size(1, 2, x)]] fn f() -> void {}", + EXPECT("[[workgroup_size(1, 2, x)]] fn f() {}", "test.wgsl:1:24 error: expected signed integer literal for " "workgroup_size z parameter\n" - "[[workgroup_size(1, 2, x)]] fn f() -> void {}\n" + "[[workgroup_size(1, 2, x)]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeZNegative) { - EXPECT("[[workgroup_size(1, 2, -1)]] fn f() -> void {}", + EXPECT("[[workgroup_size(1, 2, -1)]] fn f() {}", "test.wgsl:1:24 error: workgroup_size z parameter must be greater " "than 0\n" - "[[workgroup_size(1, 2, -1)]] fn f() -> void {}\n" + "[[workgroup_size(1, 2, -1)]] fn f() {}\n" " ^^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclDecoWorkgroupSizeZZero) { - EXPECT("[[workgroup_size(1, 2, 0)]] fn f() -> void {}", + EXPECT("[[workgroup_size(1, 2, 0)]] fn f() {}", "test.wgsl:1:24 error: workgroup_size z parameter must be greater " "than 0\n" - "[[workgroup_size(1, 2, 0)]] fn f() -> void {}\n" + "[[workgroup_size(1, 2, 0)]] fn f() {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclMissingIdentifier) { - EXPECT("fn () -> void {}", + EXPECT("fn () {}", "test.wgsl:1:4 error: expected identifier for function declaration\n" - "fn () -> void {}\n" + "fn () {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclMissingLParen) { - EXPECT("fn f) -> void {}", + EXPECT("fn f) {}", "test.wgsl:1:5 error: expected '(' for function declaration\n" - "fn f) -> void {}\n" + "fn f) {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclMissingRParen) { - EXPECT("fn f( -> void {}", + EXPECT("fn f( {}", "test.wgsl:1:7 error: expected ')' for function declaration\n" - "fn f( -> void {}\n" - " ^^\n"); + "fn f( {}\n" + " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclMissingArrow) { EXPECT("fn f() void {}", - "test.wgsl:1:8 error: expected '->' for function declaration\n" + "test.wgsl:1:8 error: expected '{'\n" "fn f() void {}\n" " ^^^^\n"); } @@ -433,38 +433,38 @@ TEST_F(ParserImplErrorTest, FunctionDeclInvalidReturnType) { } TEST_F(ParserImplErrorTest, FunctionDeclParamMissingColon) { - EXPECT("fn f(x) -> void {}", + EXPECT("fn f(x) {}", "test.wgsl:1:7 error: expected ':' for parameter\n" - "fn f(x) -> void {}\n" + "fn f(x) {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclParamInvalidType) { - EXPECT("fn f(x : 1) -> void {}", + EXPECT("fn f(x : 1) {}", "test.wgsl:1:10 error: invalid type for parameter\n" - "fn f(x : 1) -> void {}\n" + "fn f(x : 1) {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclParamMissing) { - EXPECT("fn f(x : i32, ) -> void {}", + EXPECT("fn f(x : i32, ) {}", "test.wgsl:1:15 error: expected identifier for parameter\n" - "fn f(x : i32, ) -> void {}\n" + "fn f(x : i32, ) {}\n" " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclMissingLBrace) { - EXPECT("fn f() -> void }", - "test.wgsl:1:16 error: expected '{'\n" - "fn f() -> void }\n" - " ^\n"); + EXPECT("fn f() }", + "test.wgsl:1:8 error: expected '{'\n" + "fn f() }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, FunctionDeclMissingRBrace) { - EXPECT("fn f() -> void {", - "test.wgsl:1:17 error: expected '}'\n" - "fn f() -> void {\n" - " ^\n"); + EXPECT("fn f() {", + "test.wgsl:1:9 error: expected '}'\n" + "fn f() {\n" + " ^\n"); } TEST_F(ParserImplErrorTest, FunctionMissingOpenLine) { @@ -1127,52 +1127,52 @@ TEST_F(ParserImplErrorTest, GlobalDeclTextureExplicitStorageClass) { } TEST_F(ParserImplErrorTest, IfStmtMissingLParen) { - EXPECT("fn f() -> void { if true) {} }", - "test.wgsl:1:21 error: expected '('\n" - "fn f() -> void { if true) {} }\n" - " ^^^^\n"); + EXPECT("fn f() { if true) {} }", + "test.wgsl:1:13 error: expected '('\n" + "fn f() { if true) {} }\n" + " ^^^^\n"); } TEST_F(ParserImplErrorTest, IfStmtMissingRParen) { - EXPECT("fn f() -> void { if (true {} }", - "test.wgsl:1:27 error: expected ')'\n" - "fn f() -> void { if (true {} }\n" - " ^\n"); + EXPECT("fn f() { if (true {} }", + "test.wgsl:1:19 error: expected ')'\n" + "fn f() { if (true {} }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, IfStmtInvalidCond) { - EXPECT("fn f() -> void { if (>) {} }", - "test.wgsl:1:22 error: unable to parse expression\n" - "fn f() -> void { if (>) {} }\n" - " ^\n"); + EXPECT("fn f() { if (>) {} }", + "test.wgsl:1:14 error: unable to parse expression\n" + "fn f() { if (>) {} }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, LogicalAndInvalidExpr) { - EXPECT("fn f() -> void { return 1 && >; }", - "test.wgsl:1:30 error: unable to parse right side of && expression\n" - "fn f() -> void { return 1 && >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 && >; }", + "test.wgsl:1:22 error: unable to parse right side of && expression\n" + "fn f() { return 1 && >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, LogicalOrInvalidExpr) { - EXPECT("fn f() -> void { return 1 || >; }", - "test.wgsl:1:30 error: unable to parse right side of || expression\n" - "fn f() -> void { return 1 || >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 || >; }", + "test.wgsl:1:22 error: unable to parse right side of || expression\n" + "fn f() { return 1 || >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, LoopMissingLBrace) { - EXPECT("fn f() -> void { loop }", - "test.wgsl:1:23 error: expected '{' for loop\n" - "fn f() -> void { loop }\n" - " ^\n"); + EXPECT("fn f() { loop }", + "test.wgsl:1:15 error: expected '{' for loop\n" + "fn f() { loop }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, LoopMissingRBrace) { - EXPECT("fn f() -> void { loop {", - "test.wgsl:1:24 error: expected '}' for loop\n" - "fn f() -> void { loop {\n" - " ^\n"); + EXPECT("fn f() { loop {", + "test.wgsl:1:16 error: expected '}' for loop\n" + "fn f() { loop {\n" + " ^\n"); } TEST_F(ParserImplErrorTest, MaxErrorsReached) { @@ -1196,123 +1196,123 @@ TEST_F(ParserImplErrorTest, MaxErrorsReached) { } TEST_F(ParserImplErrorTest, MemberExprMissingIdentifier) { - EXPECT("fn f() -> void { x = a.; }", - "test.wgsl:1:24 error: expected identifier for member accessor\n" - "fn f() -> void { x = a.; }\n" - " ^\n"); + EXPECT("fn f() { x = a.; }", + "test.wgsl:1:16 error: expected identifier for member accessor\n" + "fn f() { x = a.; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, MultiplicativeInvalidExpr) { - EXPECT("fn f() -> void { return 1.0 * <; }", - "test.wgsl:1:31 error: unable to parse right side of * expression\n" - "fn f() -> void { return 1.0 * <; }\n" - " ^\n"); + EXPECT("fn f() { return 1.0 * <; }", + "test.wgsl:1:23 error: unable to parse right side of * expression\n" + "fn f() { return 1.0 * <; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, OrInvalidExpr) { - EXPECT("fn f() -> void { return 1 | >; }", - "test.wgsl:1:29 error: unable to parse right side of | expression\n" - "fn f() -> void { return 1 | >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 | >; }", + "test.wgsl:1:21 error: unable to parse right side of | expression\n" + "fn f() { return 1 | >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, RelationalInvalidExpr) { - EXPECT("fn f() -> void { return 1 < >; }", - "test.wgsl:1:29 error: unable to parse right side of < expression\n" - "fn f() -> void { return 1 < >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 < >; }", + "test.wgsl:1:21 error: unable to parse right side of < expression\n" + "fn f() { return 1 < >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ReturnStmtMissingSemicolon) { - EXPECT("fn f() -> void { return }", - "test.wgsl:1:25 error: expected ';' for return statement\n" - "fn f() -> void { return }\n" - " ^\n"); + EXPECT("fn f() { return }", + "test.wgsl:1:17 error: expected ';' for return statement\n" + "fn f() { return }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, ShiftInvalidExpr) { - EXPECT("fn f() -> void { return 1 << >; }", - "test.wgsl:1:30 error: unable to parse right side of << expression\n" - "fn f() -> void { return 1 << >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 << >; }", + "test.wgsl:1:22 error: unable to parse right side of << expression\n" + "fn f() { return 1 << >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, SwitchStmtMissingLBrace) { - EXPECT("fn f() -> void { switch(1) }", - "test.wgsl:1:28 error: expected '{' for switch statement\n" - "fn f() -> void { switch(1) }\n" - " ^\n"); + EXPECT("fn f() { switch(1) }", + "test.wgsl:1:20 error: expected '{' for switch statement\n" + "fn f() { switch(1) }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, SwitchStmtMissingRBrace) { - EXPECT("fn f() -> void { switch(1) {", - "test.wgsl:1:29 error: expected '}' for switch statement\n" - "fn f() -> void { switch(1) {\n" - " ^\n"); + EXPECT("fn f() { switch(1) {", + "test.wgsl:1:21 error: expected '}' for switch statement\n" + "fn f() { switch(1) {\n" + " ^\n"); } TEST_F(ParserImplErrorTest, SwitchStmtInvalidCase) { - EXPECT("fn f() -> void { switch(1) { case ^: } }", - "test.wgsl:1:35 error: unable to parse case selectors\n" - "fn f() -> void { switch(1) { case ^: } }\n" - " ^\n"); + EXPECT("fn f() { switch(1) { case ^: } }", + "test.wgsl:1:27 error: unable to parse case selectors\n" + "fn f() { switch(1) { case ^: } }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, SwitchStmtInvalidCase2) { EXPECT( - "fn f() -> void { switch(1) { case false: } }", - "test.wgsl:1:35 error: invalid case selector must be an integer value\n" - "fn f() -> void { switch(1) { case false: } }\n" - " ^^^^^\n"); + "fn f() { switch(1) { case false: } }", + "test.wgsl:1:27 error: invalid case selector must be an integer value\n" + "fn f() { switch(1) { case false: } }\n" + " ^^^^^\n"); } TEST_F(ParserImplErrorTest, SwitchStmtCaseMissingColon) { - EXPECT("fn f() -> void { switch(1) { case 1 {} } }", - "test.wgsl:1:37 error: expected ':' for case statement\n" - "fn f() -> void { switch(1) { case 1 {} } }\n" - " ^\n"); + EXPECT("fn f() { switch(1) { case 1 {} } }", + "test.wgsl:1:29 error: expected ':' for case statement\n" + "fn f() { switch(1) { case 1 {} } }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, SwitchStmtCaseMissingLBrace) { - EXPECT("fn f() -> void { switch(1) { case 1: } }", - "test.wgsl:1:38 error: expected '{' for case statement\n" - "fn f() -> void { switch(1) { case 1: } }\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, SwitchStmtCaseMissingRBrace) { - EXPECT("fn f() -> void { switch(1) { case 1: {", - "test.wgsl:1:39 error: expected '}' for case statement\n" - "fn f() -> void { switch(1) { case 1: {\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, SwitchStmtCaseFallthroughMissingSemicolon) { - EXPECT("fn f() -> void { switch(1) { case 1: { fallthrough } case 2: {} } }", - "test.wgsl:1:52 error: expected ';' for fallthrough statement\n" - "fn f() -> void { switch(1) { case 1: { fallthrough } case 2: {} } }\n" - " ^\n"); -} - -TEST_F(ParserImplErrorTest, VarStmtMissingSemicolon) { - EXPECT("fn f() -> void { var a : u32 }", - "test.wgsl:1:30 error: expected ';' for variable declaration\n" - "fn f() -> void { var a : u32 }\n" + EXPECT("fn f() { switch(1) { case 1: } }", + "test.wgsl:1:30 error: expected '{' for case statement\n" + "fn f() { switch(1) { case 1: } }\n" " ^\n"); } +TEST_F(ParserImplErrorTest, SwitchStmtCaseMissingRBrace) { + EXPECT("fn f() { switch(1) { case 1: {", + "test.wgsl:1:31 error: expected '}' for case statement\n" + "fn f() { switch(1) { case 1: {\n" + " ^\n"); +} + +TEST_F(ParserImplErrorTest, SwitchStmtCaseFallthroughMissingSemicolon) { + EXPECT("fn f() { switch(1) { case 1: { fallthrough } case 2: {} } }", + "test.wgsl:1:44 error: expected ';' for fallthrough statement\n" + "fn f() { switch(1) { case 1: { fallthrough } case 2: {} } }\n" + " ^\n"); +} + +TEST_F(ParserImplErrorTest, VarStmtMissingSemicolon) { + EXPECT("fn f() { var a : u32 }", + "test.wgsl:1:22 error: expected ';' for variable declaration\n" + "fn f() { var a : u32 }\n" + " ^\n"); +} + TEST_F(ParserImplErrorTest, VarStmtInvalidAssignment) { - EXPECT("fn f() -> void { var a : u32 = >; }", - "test.wgsl:1:32 error: missing constructor for variable declaration\n" - "fn f() -> void { var a : u32 = >; }\n" - " ^\n"); + EXPECT("fn f() { var a : u32 = >; }", + "test.wgsl:1:24 error: missing constructor for variable declaration\n" + "fn f() { var a : u32 = >; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, UnaryInvalidExpr) { - EXPECT("fn f() -> void { return !<; }", - "test.wgsl:1:26 error: unable to parse right side of ! expression\n" - "fn f() -> void { return !<; }\n" - " ^\n"); + EXPECT("fn f() { return !<; }", + "test.wgsl:1:18 error: unable to parse right side of ! expression\n" + "fn f() { return !<; }\n" + " ^\n"); } TEST_F(ParserImplErrorTest, UnexpectedToken) { @@ -1323,10 +1323,10 @@ TEST_F(ParserImplErrorTest, UnexpectedToken) { } TEST_F(ParserImplErrorTest, XorInvalidExpr) { - EXPECT("fn f() -> void { return 1 ^ >; }", - "test.wgsl:1:29 error: unable to parse right side of ^ expression\n" - "fn f() -> void { return 1 ^ >; }\n" - " ^\n"); + EXPECT("fn f() { return 1 ^ >; }", + "test.wgsl:1:21 error: unable to parse right side of ^ expression\n" + "fn f() { return 1 ^ >; }\n" + " ^\n"); } } // namespace diff --git a/src/reader/wgsl/parser_impl_error_resync_test.cc b/src/reader/wgsl/parser_impl_error_resync_test.cc index 13bf16f1e2..db31ce32ab 100644 --- a/src/reader/wgsl/parser_impl_error_resync_test.cc +++ b/src/reader/wgsl/parser_impl_error_resync_test.cc @@ -39,9 +39,9 @@ class ParserImplErrorResyncTest : public ParserImplTest {}; TEST_F(ParserImplErrorResyncTest, BadFunctionDecls) { EXPECT(R"( fn .() -> . {} -fn x(.) . {} +fn x(.) {} [[.,.]] fn -> {} -fn good() -> void {} +fn good() {} )", "test.wgsl:2:4 error: expected identifier for function declaration\n" "fn .() -> . {}\n" @@ -52,13 +52,9 @@ fn good() -> void {} " ^\n" "\n" "test.wgsl:3:6 error: expected ')' for function declaration\n" - "fn x(.) . {}\n" + "fn x(.) {}\n" " ^\n" "\n" - "test.wgsl:3:9 error: expected '->' for function declaration\n" - "fn x(.) . {}\n" - " ^\n" - "\n" "test.wgsl:4:3 error: expected decoration\n" "[[.,.]] fn -> {}\n" " ^\n" @@ -74,7 +70,7 @@ fn good() -> void {} TEST_F(ParserImplErrorResyncTest, AssignmentStatement) { EXPECT(R"( -fn f() -> void { +fn f() { blah blah blah blah; good = 1; blah blah blah blah; @@ -97,7 +93,7 @@ fn f() -> void { TEST_F(ParserImplErrorResyncTest, DiscardStatement) { EXPECT(R"( -fn f() -> void { +fn f() { discard blah blah blah; a = 1; discard blah blah blah; @@ -142,7 +138,7 @@ struct S { // scope. TEST_F(ParserImplErrorResyncTest, NestedSyncPoints) { EXPECT(R"( -fn f() -> void { +fn f() { x = 1; discard } @@ -160,7 +156,7 @@ struct S { blah }; TEST_F(ParserImplErrorResyncTest, BracketCounting) { EXPECT(R"( [[woof[[[[]]]]]] -fn f(x(((())))) -> void { +fn f(x(((())))) { meow = {{{}}} } struct S { blah }; @@ -170,7 +166,7 @@ struct S { blah }; " ^^^^\n" "\n" "test.wgsl:3:7 error: expected ':' for parameter\n" - "fn f(x(((())))) -> void {\n" + "fn f(x(((())))) {\n" " ^\n" "\n" "test.wgsl:4:10 error: unable to parse right side of assignment\n" diff --git a/src/reader/wgsl/parser_impl_for_stmt_test.cc b/src/reader/wgsl/parser_impl_for_stmt_test.cc index ad77324bf2..2db196b45a 100644 --- a/src/reader/wgsl/parser_impl_for_stmt_test.cc +++ b/src/reader/wgsl/parser_impl_for_stmt_test.cc @@ -274,7 +274,7 @@ TEST_F(ForStmtErrorTest, InvalidBody) { // Test a for loop with a body not matching statements TEST_F(ForStmtErrorTest, InvalidBodyMatch) { - std::string for_str = "for (;;) { fn main() -> void {} }"; + std::string for_str = "for (;;) { fn main() {} }"; std::string error_str = "1:12: expected '}' for for loop"; TestForWithError(for_str, error_str); diff --git a/src/reader/wgsl/parser_impl_function_decl_test.cc b/src/reader/wgsl/parser_impl_function_decl_test.cc index 42c1a436d1..4371bce7f7 100644 --- a/src/reader/wgsl/parser_impl_function_decl_test.cc +++ b/src/reader/wgsl/parser_impl_function_decl_test.cc @@ -21,7 +21,7 @@ namespace wgsl { namespace { TEST_F(ParserImplTest, FunctionDecl) { - auto p = parser("fn main(a : i32, b : f32) -> void { return; }"); + auto p = parser("fn main(a : i32, b : f32) { return; }"); auto decos = p->decoration_list(); EXPECT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(decos.errored); @@ -49,7 +49,7 @@ TEST_F(ParserImplTest, FunctionDecl) { } TEST_F(ParserImplTest, FunctionDecl_DecorationList) { - auto p = parser("[[workgroup_size(2, 3, 4)]] fn main() -> void { return; }"); + auto p = parser("[[workgroup_size(2, 3, 4)]] fn main() { return; }"); auto decos = p->decoration_list(); EXPECT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(decos.errored); @@ -87,7 +87,7 @@ TEST_F(ParserImplTest, FunctionDecl_DecorationList) { TEST_F(ParserImplTest, FunctionDecl_DecorationList_MultipleEntries) { auto p = parser(R"( [[workgroup_size(2, 3, 4), workgroup_size(5, 6, 7)]] -fn main() -> void { return; })"); +fn main() { return; })"); auto decos = p->decoration_list(); EXPECT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(decos.errored); @@ -132,7 +132,7 @@ TEST_F(ParserImplTest, FunctionDecl_DecorationList_MultipleLists) { auto p = parser(R"( [[workgroup_size(2, 3, 4)]] [[workgroup_size(5, 6, 7)]] -fn main() -> void { return; })"); +fn main() { return; })"); auto decorations = p->decoration_list(); EXPECT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(decorations.errored); @@ -219,7 +219,7 @@ TEST_F(ParserImplTest, FunctionDecl_InvalidHeader) { } TEST_F(ParserImplTest, FunctionDecl_InvalidBody) { - auto p = parser("fn main() -> void { return }"); + auto p = parser("fn main() { return }"); auto decos = p->decoration_list(); EXPECT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(decos.errored); @@ -229,11 +229,11 @@ TEST_F(ParserImplTest, FunctionDecl_InvalidBody) { EXPECT_FALSE(f.matched); EXPECT_TRUE(p->has_error()); EXPECT_EQ(f.value, nullptr); - EXPECT_EQ(p->error(), "1:28: expected ';' for return statement"); + EXPECT_EQ(p->error(), "1:20: expected ';' for return statement"); } TEST_F(ParserImplTest, FunctionDecl_MissingLeftBrace) { - auto p = parser("fn main() -> void return; }"); + auto p = parser("fn main() return; }"); auto decos = p->decoration_list(); EXPECT_FALSE(p->has_error()) << p->error(); ASSERT_FALSE(decos.errored); @@ -243,7 +243,7 @@ TEST_F(ParserImplTest, FunctionDecl_MissingLeftBrace) { EXPECT_FALSE(f.matched); EXPECT_TRUE(p->has_error()); EXPECT_EQ(f.value, nullptr); - EXPECT_EQ(p->error(), "1:19: expected '{'"); + EXPECT_EQ(p->error(), "1:11: expected '{'"); } } // namespace diff --git a/src/reader/wgsl/parser_impl_function_header_test.cc b/src/reader/wgsl/parser_impl_function_header_test.cc index 9ab73193b5..c4a064d3ef 100644 --- a/src/reader/wgsl/parser_impl_function_header_test.cc +++ b/src/reader/wgsl/parser_impl_function_header_test.cc @@ -20,7 +20,7 @@ namespace wgsl { namespace { TEST_F(ParserImplTest, FunctionHeader) { - auto p = parser("fn main(a : i32, b: f32) -> void"); + auto p = parser("fn main(a : i32, b: f32)"); auto f = p->function_header(); ASSERT_FALSE(p->has_error()) << p->error(); EXPECT_TRUE(f.matched); @@ -50,7 +50,7 @@ TEST_F(ParserImplTest, FunctionHeader_DecoratedReturnType) { } TEST_F(ParserImplTest, FunctionHeader_MissingIdent) { - auto p = parser("fn () -> void"); + auto p = parser("fn ()"); auto f = p->function_header(); EXPECT_FALSE(f.matched); EXPECT_TRUE(f.errored); @@ -94,15 +94,6 @@ TEST_F(ParserImplTest, FunctionHeader_MissingParenRight) { EXPECT_EQ(p->error(), "1:10: expected ')' for function declaration"); } -TEST_F(ParserImplTest, FunctionHeader_MissingArrow) { - auto p = parser("fn main() i32"); - auto f = p->function_header(); - EXPECT_FALSE(f.matched); - EXPECT_TRUE(f.errored); - EXPECT_TRUE(p->has_error()); - EXPECT_EQ(p->error(), "1:11: expected '->' for function declaration"); -} - TEST_F(ParserImplTest, FunctionHeader_InvalidReturnType) { auto p = parser("fn main() -> invalid"); auto f = p->function_header(); @@ -121,6 +112,19 @@ TEST_F(ParserImplTest, FunctionHeader_MissingReturnType) { EXPECT_EQ(p->error(), "1:13: unable to determine function return type"); } +TEST_F(ParserImplTest, FunctionHeader_ArrowVoid) { + auto p = parser("fn main() -> void"); + auto f = p->function_header(); + EXPECT_TRUE(f.matched); + EXPECT_FALSE(f.errored); + EXPECT_EQ( + p->builder().Diagnostics().str(), + R"(test.wgsl:1:14 warning: use of deprecated language feature: omit '-> void' for functions that do not return a value +fn main() -> void + ^^^^ +)"); +} + } // namespace } // namespace wgsl } // namespace reader diff --git a/src/reader/wgsl/parser_impl_global_decl_test.cc b/src/reader/wgsl/parser_impl_global_decl_test.cc index de3d47169a..ab7f6d43ec 100644 --- a/src/reader/wgsl/parser_impl_global_decl_test.cc +++ b/src/reader/wgsl/parser_impl_global_decl_test.cc @@ -127,7 +127,7 @@ TEST_F(ParserImplTest, GlobalDecl_TypeAlias_MissingSemicolon) { } TEST_F(ParserImplTest, GlobalDecl_Function) { - auto p = parser("fn main() -> void { return; }"); + auto p = parser("fn main() { return; }"); p->expect_global_decl(); ASSERT_FALSE(p->has_error()) << p->error(); @@ -138,7 +138,7 @@ TEST_F(ParserImplTest, GlobalDecl_Function) { } TEST_F(ParserImplTest, GlobalDecl_Function_WithDecoration) { - auto p = parser("[[workgroup_size(2)]] fn main() -> void { return; }"); + auto p = parser("[[workgroup_size(2)]] fn main() { return; }"); p->expect_global_decl(); ASSERT_FALSE(p->has_error()) << p->error(); diff --git a/src/reader/wgsl/parser_impl_if_stmt_test.cc b/src/reader/wgsl/parser_impl_if_stmt_test.cc index 7be5ec62de..fdee7c8201 100644 --- a/src/reader/wgsl/parser_impl_if_stmt_test.cc +++ b/src/reader/wgsl/parser_impl_if_stmt_test.cc @@ -78,7 +78,7 @@ TEST_F(ParserImplTest, IfStmt_MissingCondition) { } TEST_F(ParserImplTest, IfStmt_InvalidBody) { - auto p = parser("if (a) { fn main() -> void {}}"); + auto p = parser("if (a) { fn main() {}}"); auto e = p->if_stmt(); EXPECT_FALSE(e.matched); EXPECT_TRUE(e.errored); diff --git a/src/reader/wgsl/parser_impl_switch_body_test.cc b/src/reader/wgsl/parser_impl_switch_body_test.cc index 7fb43928c1..39f33b4b44 100644 --- a/src/reader/wgsl/parser_impl_switch_body_test.cc +++ b/src/reader/wgsl/parser_impl_switch_body_test.cc @@ -93,7 +93,7 @@ TEST_F(ParserImplTest, SwitchBody_Case_MissingBracketRight) { } TEST_F(ParserImplTest, SwitchBody_Case_InvalidCaseBody) { - auto p = parser("case 1: { fn main() -> void {} }"); + auto p = parser("case 1: { fn main() {} }"); auto e = p->switch_body(); EXPECT_TRUE(p->has_error()); EXPECT_TRUE(e.errored); @@ -201,7 +201,7 @@ TEST_F(ParserImplTest, SwitchBody_Default_MissingBracketRight) { } TEST_F(ParserImplTest, SwitchBody_Default_InvalidCaseBody) { - auto p = parser("default: { fn main() -> void {} }"); + auto p = parser("default: { fn main() {} }"); auto e = p->switch_body(); EXPECT_TRUE(p->has_error()); EXPECT_TRUE(e.errored); diff --git a/src/reader/wgsl/parser_impl_test.cc b/src/reader/wgsl/parser_impl_test.cc index d85eeaac76..861b819bf2 100644 --- a/src/reader/wgsl/parser_impl_test.cc +++ b/src/reader/wgsl/parser_impl_test.cc @@ -29,7 +29,7 @@ TEST_F(ParserImplTest, Parses) { [[location(0)]] var gl_FragColor : vec4; [[stage(vertex)]] -fn main() -> void { +fn main() { gl_FragColor = vec4(.4, .2, .3, 1); } )"); diff --git a/src/reader/wgsl/parser_test.cc b/src/reader/wgsl/parser_test.cc index b63c557ba6..cd01174acf 100644 --- a/src/reader/wgsl/parser_test.cc +++ b/src/reader/wgsl/parser_test.cc @@ -37,7 +37,7 @@ TEST_F(ParserTest, Parses) { [[location(0)]] var gl_FragColor : vec4; [[stage(vertex)]] -fn main() -> void { +fn main() { gl_FragColor = vec4(.4, .2, .3, 1.); } )"); diff --git a/src/resolver/function_validation_test.cc b/src/resolver/function_validation_test.cc index 562dc4c72b..77c06f0116 100644 --- a/src/resolver/function_validation_test.cc +++ b/src/resolver/function_validation_test.cc @@ -48,7 +48,7 @@ TEST_F(ResolverFunctionValidationTest, FunctionNamesMustBeUnique_fail) { TEST_F(ResolverFunctionValidationTest, VoidFunctionEndWithoutReturnStatement_Pass) { // [[stage(vertex)]] - // fn func -> void { var a:i32 = 2; } + // fn func { var a:i32 = 2; } auto* var = Var("a", ty.i32(), ast::StorageClass::kNone, Expr(2)); Func(Source{Source::Location{12, 34}}, "func", ast::VariableList{}, @@ -83,7 +83,7 @@ TEST_F(ResolverFunctionValidationTest, FunctionEndWithoutReturnStatement_Fail) { TEST_F(ResolverFunctionValidationTest, VoidFunctionEndWithoutReturnStatementEmptyBody_Pass) { // [[stage(vertex)]] - // fn func -> void {} + // fn func {} Func(Source{Source::Location{12, 34}}, "func", ast::VariableList{}, ty.void_(), ast::StatementList{}, @@ -110,7 +110,7 @@ TEST_F(ResolverFunctionValidationTest, TEST_F(ResolverFunctionValidationTest, FunctionTypeMustMatchReturnStatementType_Pass) { // [[stage(vertex)]] - // fn func -> void { return; } + // fn func { return; } Func("func", ast::VariableList{}, ty.void_(), ast::StatementList{ @@ -125,7 +125,7 @@ TEST_F(ResolverFunctionValidationTest, TEST_F(ResolverFunctionValidationTest, FunctionTypeMustMatchReturnStatementType_fail) { - // fn func -> void { return 2; } + // fn func { return 2; } Func("func", ast::VariableList{}, ty.void_(), ast::StatementList{ create(Source{Source::Location{12, 34}}, @@ -216,7 +216,7 @@ TEST_F(ResolverFunctionValidationTest, TEST_F(ResolverFunctionValidationTest, PipelineStage_MustBeUnique_Fail) { // [[stage(fragment)]] // [[stage(vertex)]] - // fn main() -> void { return; } + // fn main() { return; } Func(Source{Source::Location{12, 34}}, "main", ast::VariableList{}, ty.void_(), ast::StatementList{ @@ -244,7 +244,7 @@ TEST_F(ResolverFunctionValidationTest, NoPipelineEntryPoints) { } TEST_F(ResolverFunctionValidationTest, FunctionVarInitWithParam) { - // fn foo(bar : f32) -> void{ + // fn foo(bar : f32){ // var baz : f32 = bar; // } @@ -258,7 +258,7 @@ TEST_F(ResolverFunctionValidationTest, FunctionVarInitWithParam) { } TEST_F(ResolverFunctionValidationTest, FunctionConstInitWithParam) { - // fn foo(bar : f32) -> void{ + // fn foo(bar : f32){ // const baz : f32 = bar; // } diff --git a/src/resolver/resolver_test.cc b/src/resolver/resolver_test.cc index 8b02b933b2..470adab39b 100644 --- a/src/resolver/resolver_test.cc +++ b/src/resolver/resolver_test.cc @@ -285,7 +285,7 @@ TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScope) { } TEST_F(ResolverTest, Stmt_VariableDecl_OuterScopeAfterInnerScope) { - // fn func_i32() -> void { + // fn func_i32() { // { // var foo : i32 = 2; // var bar : i32 = foo; @@ -345,11 +345,11 @@ TEST_F(ResolverTest, Stmt_VariableDecl_OuterScopeAfterInnerScope) { } TEST_F(ResolverTest, Stmt_VariableDecl_ModuleScopeAfterFunctionScope) { - // fn func_i32() -> void { + // fn func_i32() { // var foo : i32 = 2; // } // var foo : f32 = 2.0; - // fn func_f32() -> void { + // fn func_f32() { // var bar : f32 = foo; // } diff --git a/src/resolver/type_constructor_validation_test.cc b/src/resolver/type_constructor_validation_test.cc index 838e1e0637..15bb536060 100644 --- a/src/resolver/type_constructor_validation_test.cc +++ b/src/resolver/type_constructor_validation_test.cc @@ -154,7 +154,7 @@ TEST_P(InferTypeTest_FromCallExpression, All) { // return vec3(0.0, 0.0, 0.0); // } // - // fn bar() -> void + // fn bar() // { // var a = foo(); // } diff --git a/src/resolver/type_validation_test.cc b/src/resolver/type_validation_test.cc index 4ea6567195..848e998413 100644 --- a/src/resolver/type_validation_test.cc +++ b/src/resolver/type_validation_test.cc @@ -111,7 +111,7 @@ TEST_F(ResolverTypeValidationTest, GlobalVariableNotUnique_Fail) { TEST_F(ResolverTypeValidationTest, GlobalVariableFunctionVariableNotUnique_Pass) { - // fn my_func -> void { + // fn my_func() { // var a: f32 = 2.0; // } // var a: f32 = 2.1; @@ -130,7 +130,7 @@ TEST_F(ResolverTypeValidationTest, TEST_F(ResolverTypeValidationTest, GlobalVariableFunctionVariableNotUnique_Fail) { // var a: f32 = 2.1; - // fn my_func -> void { + // fn my_func() { // var a: f32 = 2.0; // return 0; // } @@ -150,7 +150,7 @@ TEST_F(ResolverTypeValidationTest, } TEST_F(ResolverTypeValidationTest, RedeclaredIdentifier_Fail) { - // fn my_func() -> void { + // fn my_func()() { // var a :i32 = 2; // var a :f21 = 2.0; // } @@ -293,7 +293,7 @@ TEST_F(ResolverTypeValidationTest, TEST_F(ResolverTypeValidationTest, RuntimeArrayInFunction_Fail) { /// [[stage(vertex)]] - // fn func -> void { var a : array; } + // fn func() { var a : array; } auto* var = Var(Source{{12, 34}}, "a", ty.array(), ast::StorageClass::kNone); diff --git a/src/resolver/validation_test.cc b/src/resolver/validation_test.cc index 408f0b209f..2ed500e5eb 100644 --- a/src/resolver/validation_test.cc +++ b/src/resolver/validation_test.cc @@ -83,8 +83,8 @@ TEST_F(ResolverValidationTest, Stmt_Error_Unknown) { } TEST_F(ResolverValidationTest, Stmt_Call_undeclared) { - // fn main() -> void {func(); return; } - // fn func() -> void { return; } + // fn main() {func(); return; } + // fn func() { return; } SetSource(Source::Location{12, 34}); auto* call_expr = Call("func"); @@ -110,7 +110,7 @@ TEST_F(ResolverValidationTest, Stmt_Call_undeclared) { } TEST_F(ResolverValidationTest, Stmt_Call_recursive) { - // fn main() -> void {main(); } + // fn main() {main(); } SetSource(Source::Location{12, 34}); auto* call_expr = Call("main"); @@ -241,7 +241,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableInBlockStatement_Fail) { } TEST_F(ResolverValidationTest, UsingUndefinedVariableGlobalVariableAfter_Fail) { - // fn my_func() -> void { + // fn my_func() { // global_var = 3.14f; // } // var global_var: f32 = 2.1; @@ -266,7 +266,7 @@ TEST_F(ResolverValidationTest, UsingUndefinedVariableGlobalVariableAfter_Fail) { TEST_F(ResolverValidationTest, UsingUndefinedVariableGlobalVariable_Pass) { // var global_var: f32 = 2.1; - // fn my_func() -> void { + // fn my_func() { // global_var = 3.14; // return; // } diff --git a/src/transform/binding_remapper_test.cc b/src/transform/binding_remapper_test.cc index cc04bf04e7..5e798a6ab2 100644 --- a/src/transform/binding_remapper_test.cc +++ b/src/transform/binding_remapper_test.cc @@ -35,7 +35,7 @@ struct S { [[group(3), binding(2)]] var b : S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -60,7 +60,7 @@ struct S { [[group(3), binding(2)]] var b : S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -74,7 +74,7 @@ struct S { [[group(3), binding(2)]] var b : S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -106,7 +106,7 @@ S; [[group(4), binding(3)]] var c : S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -125,7 +125,7 @@ S; S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -165,7 +165,7 @@ type A = S; [[group(4), binding(3)]] var c : A; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -190,7 +190,7 @@ S; [[group(4), binding(3)]] var c : [[access(write)]] S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -219,7 +219,7 @@ S; [[group(3), binding(2)]] var b : S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -235,7 +235,7 @@ S; S; [[stage(compute)]] -fn f() -> void { +fn f() { } )"; @@ -264,7 +264,7 @@ struct S { [[group(3), binding(2)]] var b : S; [[stage(compute)]] -fn f() -> void {} +fn f() {} )"; auto* expect = "error: BindingRemapper did not find the remapping data"; diff --git a/src/transform/bound_array_accessors_test.cc b/src/transform/bound_array_accessors_test.cc index fc9b87ebc2..bafd6c67cf 100644 --- a/src/transform/bound_array_accessors_test.cc +++ b/src/transform/bound_array_accessors_test.cc @@ -28,7 +28,7 @@ var a : array; const c : u32 = 1u; -fn f() -> void { +fn f() { const b : ptr = a[c]; } )"; @@ -38,7 +38,7 @@ var a : array; const c : u32 = 1u; -fn f() -> void { +fn f() { const b : ptr = a[min(u32(c), 2u)]; } )"; @@ -56,7 +56,7 @@ var b : array; var i : u32; -fn f() -> void { +fn f() { var c : f32 = a[ b[i] ]; } )"; @@ -68,7 +68,7 @@ var b : array; var i : u32; -fn f() -> void { +fn f() { var c : f32 = a[min(u32(b[min(u32(i), 4u)]), 2u)]; } )"; @@ -82,7 +82,7 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Scalar) { auto* src = R"( var a : array; -fn f() -> void { +fn f() { var b : f32 = a[1]; } )"; @@ -90,7 +90,7 @@ fn f() -> void { auto* expect = R"( var a : array; -fn f() -> void { +fn f() { var b : f32 = a[1]; } )"; @@ -106,7 +106,7 @@ var a : array; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[c + 2 - 3]; } )"; @@ -116,7 +116,7 @@ var a : array; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[min(u32(((c + 2) - 3)), 2u)]; } )"; @@ -130,7 +130,7 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_Negative) { auto* src = R"( var a : array; -fn f() -> void { +fn f() { var b : f32 = a[-1]; } )"; @@ -138,7 +138,7 @@ fn f() -> void { auto* expect = R"( var a : array; -fn f() -> void { +fn f() { var b : f32 = a[0]; } )"; @@ -152,7 +152,7 @@ TEST_F(BoundArrayAccessorsTest, Array_Idx_OutOfBounds) { auto* src = R"( var a : array; -fn f() -> void { +fn f() { var b : f32 = a[3]; } )"; @@ -160,7 +160,7 @@ fn f() -> void { auto* expect = R"( var a : array; -fn f() -> void { +fn f() { var b : f32 = a[2]; } )"; @@ -174,7 +174,7 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Scalar) { auto* src = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a[1]; } )"; @@ -182,7 +182,7 @@ fn f() -> void { auto* expect = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a[1]; } )"; @@ -198,7 +198,7 @@ var a : vec3; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[c + 2 - 3]; } )"; @@ -208,7 +208,7 @@ var a : vec3; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[min(u32(((c + 2) - 3)), 2u)]; } )"; @@ -222,7 +222,7 @@ TEST_F(BoundArrayAccessorsTest, Vector_Swizzle_Idx_Scalar) { auto* src = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a.xy[2]; } )"; @@ -230,7 +230,7 @@ fn f() -> void { auto* expect = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a.xy[1]; } )"; @@ -246,7 +246,7 @@ var a : vec3; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a.xy[c]; } )"; @@ -256,7 +256,7 @@ var a : vec3; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a.xy[min(u32(c), 1u)]; } )"; @@ -271,7 +271,7 @@ var a : vec3; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a.xy[c + 2 - 3]; } )"; @@ -281,7 +281,7 @@ var a : vec3; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a.xy[min(u32(((c + 2) - 3)), 1u)]; } )"; @@ -295,7 +295,7 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_Negative) { auto* src = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a[-1]; } )"; @@ -303,7 +303,7 @@ fn f() -> void { auto* expect = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a[0]; } )"; @@ -317,7 +317,7 @@ TEST_F(BoundArrayAccessorsTest, Vector_Idx_OutOfBounds) { auto* src = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a[3]; } )"; @@ -325,7 +325,7 @@ fn f() -> void { auto* expect = R"( var a : vec3; -fn f() -> void { +fn f() { var b : f32 = a[2]; } )"; @@ -339,7 +339,7 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Scalar) { auto* src = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[2][1]; } )"; @@ -347,7 +347,7 @@ fn f() -> void { auto* expect = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[2][1]; } )"; @@ -363,7 +363,7 @@ var a : mat3x2; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[c + 2 - 3][1]; } )"; @@ -373,7 +373,7 @@ var a : mat3x2; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[min(u32(((c + 2) - 3)), 2u)][1]; } )"; @@ -389,7 +389,7 @@ var a : mat3x2; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[1][c + 2 - 3]; } )"; @@ -399,7 +399,7 @@ var a : mat3x2; var c : i32; -fn f() -> void { +fn f() { var b : f32 = a[1][min(u32(((c + 2) - 3)), 1u)]; } )"; @@ -413,7 +413,7 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Column) { auto* src = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[-1][1]; } )"; @@ -421,7 +421,7 @@ fn f() -> void { auto* expect = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[0][1]; } )"; @@ -435,7 +435,7 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_Negative_Row) { auto* src = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[2][-1]; } )"; @@ -443,7 +443,7 @@ fn f() -> void { auto* expect = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[2][0]; } )"; @@ -457,7 +457,7 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Column) { auto* src = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[5][1]; } )"; @@ -465,7 +465,7 @@ fn f() -> void { auto* expect = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[2][1]; } )"; @@ -479,7 +479,7 @@ TEST_F(BoundArrayAccessorsTest, Matrix_Idx_OutOfBounds_Row) { auto* src = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[2][5]; } )"; @@ -487,7 +487,7 @@ fn f() -> void { auto* expect = R"( var a : mat3x2; -fn f() -> void { +fn f() { var b : f32 = a[2][1]; } )"; @@ -542,7 +542,7 @@ struct S { }; var s : S; -fn f() -> void { +fn f() { var d : f32 = s.b[25]; } )"; @@ -556,7 +556,7 @@ struct S { var s : S; -fn f() -> void { +fn f() { var d : f32 = s.b[min(u32(25), (arrayLength(s.b) - 1u))]; } )"; diff --git a/src/transform/canonicalize_entry_point_io_test.cc b/src/transform/canonicalize_entry_point_io_test.cc index 0f50f2d969..855f21a198 100644 --- a/src/transform/canonicalize_entry_point_io_test.cc +++ b/src/transform/canonicalize_entry_point_io_test.cc @@ -27,7 +27,7 @@ TEST_F(CanonicalizeEntryPointIOTest, Parameters) { [[stage(fragment)]] fn frag_main([[builtin(frag_coord)]] coord : vec4, [[location(1)]] loc1 : f32, - [[location(2)]] loc2 : vec4) -> void { + [[location(2)]] loc2 : vec4) { var col : f32 = (coord.x * loc1); } )"; @@ -43,7 +43,7 @@ struct tint_symbol_5 { }; [[stage(fragment)]] -fn frag_main(tint_symbol_1 : tint_symbol_5) -> void { +fn frag_main(tint_symbol_1 : tint_symbol_5) { const coord : vec4 = tint_symbol_1.coord; const loc1 : f32 = tint_symbol_1.loc1; const loc2 : vec4 = tint_symbol_1.loc2; @@ -61,7 +61,7 @@ TEST_F(CanonicalizeEntryPointIOTest, Parameter_TypeAlias) { type myf32 = f32; [[stage(fragment)]] -fn frag_main([[location(1)]] loc1 : myf32) -> void { +fn frag_main([[location(1)]] loc1 : myf32) { var x : myf32 = loc1; } )"; @@ -75,7 +75,7 @@ struct tint_symbol_4 { }; [[stage(fragment)]] -fn frag_main(tint_symbol_1 : tint_symbol_4) -> void { +fn frag_main(tint_symbol_1 : tint_symbol_4) { const loc1 : myf32 = tint_symbol_1.loc1; var x : myf32 = loc1; } @@ -91,7 +91,7 @@ TEST_F(CanonicalizeEntryPointIOTest, Parameters_EmptyBody) { [[stage(fragment)]] fn frag_main([[builtin(frag_coord)]] coord : vec4, [[location(1)]] loc1 : f32, - [[location(2)]] loc2 : vec4) -> void { + [[location(2)]] loc2 : vec4) { } )"; @@ -106,7 +106,7 @@ struct tint_symbol_5 { }; [[stage(fragment)]] -fn frag_main(tint_symbol_1 : tint_symbol_5) -> void { +fn frag_main(tint_symbol_1 : tint_symbol_5) { } )"; @@ -128,7 +128,7 @@ struct FragLocations { [[stage(fragment)]] fn frag_main(builtins : FragBuiltins, locations : FragLocations, - [[location(0)]] loc0 : f32) -> void { + [[location(0)]] loc0 : f32) { var col : f32 = ((builtins.coord.x * locations.loc1) + loc0); } )"; @@ -155,7 +155,7 @@ struct tint_symbol_10 { }; [[stage(fragment)]] -fn frag_main(tint_symbol_6 : tint_symbol_10) -> void { +fn frag_main(tint_symbol_6 : tint_symbol_10) { const builtins : FragBuiltins = FragBuiltins(tint_symbol_6.coord); const locations : FragLocations = FragLocations(tint_symbol_6.loc1, tint_symbol_6.loc2); const loc0 : f32 = tint_symbol_6.loc0; @@ -254,12 +254,12 @@ fn foo(x : FragmentInput) -> f32 { } [[stage(fragment)]] -fn frag_main1(inputs : FragmentInput) -> void { +fn frag_main1(inputs : FragmentInput) { var x : f32 = foo(inputs); } [[stage(fragment)]] -fn frag_main2(inputs : FragmentInput) -> void { +fn frag_main2(inputs : FragmentInput) { var x : f32 = foo(inputs); } )"; @@ -282,7 +282,7 @@ struct tint_symbol_6 { }; [[stage(fragment)]] -fn frag_main1(tint_symbol_4 : tint_symbol_6) -> void { +fn frag_main1(tint_symbol_4 : tint_symbol_6) { const inputs : FragmentInput = FragmentInput(tint_symbol_4.value, tint_symbol_4.mul); var x : f32 = foo(inputs); } @@ -295,7 +295,7 @@ struct tint_symbol_11 { }; [[stage(fragment)]] -fn frag_main2(tint_symbol_10 : tint_symbol_11) -> void { +fn frag_main2(tint_symbol_10 : tint_symbol_11) { const inputs : FragmentInput = FragmentInput(tint_symbol_10.value, tint_symbol_10.mul); var x : f32 = foo(inputs); } @@ -324,7 +324,7 @@ fn bar() -> f32 { } [[stage(fragment)]] -fn frag_main1(inputs : FragmentInput) -> void { +fn frag_main1(inputs : FragmentInput) { global_inputs = inputs; var r : f32 = foo(); var g : f32 = bar(); @@ -355,7 +355,7 @@ struct tint_symbol_6 { }; [[stage(fragment)]] -fn frag_main1(tint_symbol_4 : tint_symbol_6) -> void { +fn frag_main1(tint_symbol_4 : tint_symbol_6) { const inputs : FragmentInput = FragmentInput(tint_symbol_4.col1, tint_symbol_4.col2); global_inputs = inputs; var r : f32 = foo(); diff --git a/src/transform/emit_vertex_point_size_test.cc b/src/transform/emit_vertex_point_size_test.cc index 4d4e5ed859..7fb1b59ff6 100644 --- a/src/transform/emit_vertex_point_size_test.cc +++ b/src/transform/emit_vertex_point_size_test.cc @@ -24,31 +24,31 @@ using EmitVertexPointSizeTest = TransformTest; TEST_F(EmitVertexPointSizeTest, VertexStageBasic) { auto* src = R"( -fn non_entry_a() -> void { +fn non_entry_a() { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { var builtin_assignments_should_happen_before_this : f32; } -fn non_entry_b() -> void { +fn non_entry_b() { } )"; auto* expect = R"( [[builtin(pointsize)]] var tint_pointsize : f32; -fn non_entry_a() -> void { +fn non_entry_a() { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { tint_pointsize = 1.0; var builtin_assignments_should_happen_before_this : f32; } -fn non_entry_b() -> void { +fn non_entry_b() { } )"; @@ -59,29 +59,29 @@ fn non_entry_b() -> void { TEST_F(EmitVertexPointSizeTest, VertexStageEmpty) { auto* src = R"( -fn non_entry_a() -> void { +fn non_entry_a() { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { } -fn non_entry_b() -> void { +fn non_entry_b() { } )"; auto* expect = R"( [[builtin(pointsize)]] var tint_pointsize : f32; -fn non_entry_a() -> void { +fn non_entry_a() { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { tint_pointsize = 1.0; } -fn non_entry_b() -> void { +fn non_entry_b() { } )"; @@ -93,21 +93,21 @@ fn non_entry_b() -> void { TEST_F(EmitVertexPointSizeTest, NonVertexStage) { auto* src = R"( [[stage(fragment)]] -fn fragment_entry() -> void { +fn fragment_entry() { } [[stage(compute)]] -fn compute_entry() -> void { +fn compute_entry() { } )"; auto* expect = R"( [[stage(fragment)]] -fn fragment_entry() -> void { +fn fragment_entry() { } [[stage(compute)]] -fn compute_entry() -> void { +fn compute_entry() { } )"; diff --git a/src/transform/first_index_offset_test.cc b/src/transform/first_index_offset_test.cc index 2c76e82694..1075433d22 100644 --- a/src/transform/first_index_offset_test.cc +++ b/src/transform/first_index_offset_test.cc @@ -35,7 +35,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -86,7 +86,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -107,7 +107,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -134,7 +134,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -155,7 +155,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -183,7 +183,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -208,7 +208,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -239,7 +239,7 @@ fn func2() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { func2(); } )"; @@ -264,7 +264,7 @@ fn func2() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { func2(); } )"; diff --git a/src/transform/hlsl_test.cc b/src/transform/hlsl_test.cc index 27779bde42..2a61b4073c 100644 --- a/src/transform/hlsl_test.cc +++ b/src/transform/hlsl_test.cc @@ -25,7 +25,7 @@ using HlslTest = TransformTest; TEST_F(HlslTest, PromoteArrayInitializerToConstVar_Basic) { auto* src = R"( [[stage(vertex)]] -fn main() -> void { +fn main() { var f0 : f32 = 1.0; var f1 : f32 = 2.0; var f2 : f32 = 3.0; @@ -36,7 +36,7 @@ fn main() -> void { auto* expect = R"( [[stage(vertex)]] -fn main() -> void { +fn main() { var f0 : f32 = 1.0; var f1 : f32 = 2.0; var f2 : f32 = 3.0; @@ -60,7 +60,7 @@ struct S { }; [[stage(vertex)]] -fn main() -> void { +fn main() { var x : f32 = S(1, 2.0, vec3()).b; } )"; @@ -73,7 +73,7 @@ struct S { }; [[stage(vertex)]] -fn main() -> void { +fn main() { const tint_symbol_1 : S = S(1, 2.0, vec3()); var x : f32 = tint_symbol_1.b; } @@ -87,14 +87,14 @@ fn main() -> void { TEST_F(HlslTest, PromoteArrayInitializerToConstVar_ArrayInArray) { auto* src = R"( [[stage(vertex)]] -fn main() -> void { +fn main() { var i : f32 = array, 2>(array(1.0, 2.0), array(3.0, 4.0))[0][1]; } )"; auto* expect = R"( [[stage(vertex)]] -fn main() -> void { +fn main() { const tint_symbol_1 : array = array(1.0, 2.0); const tint_symbol_2 : array = array(3.0, 4.0); const tint_symbol_3 : array, 2> = array, 2>(tint_symbol_1, tint_symbol_2); @@ -124,7 +124,7 @@ struct S3 { }; [[stage(vertex)]] -fn main() -> void { +fn main() { var x : i32 = S3(S2(1, S1(2), 3)).a.b.a; } )"; @@ -145,7 +145,7 @@ struct S3 { }; [[stage(vertex)]] -fn main() -> void { +fn main() { const tint_symbol_1 : S1 = S1(2); const tint_symbol_4 : S2 = S2(1, tint_symbol_1, 3); const tint_symbol_8 : S3 = S3(tint_symbol_4); @@ -169,7 +169,7 @@ struct S2 { }; [[stage(vertex)]] -fn main() -> void { +fn main() { var x : i32 = S2(array(S1(1), S1(2), S1(3))).a[1].a; } )"; @@ -184,7 +184,7 @@ struct S2 { }; [[stage(vertex)]] -fn main() -> void { +fn main() { const tint_symbol_1 : S1 = S1(1); const tint_symbol_4 : S1 = S1(2); const tint_symbol_5 : S1 = S1(3); @@ -208,7 +208,7 @@ struct S { }; [[stage(vertex)]] -fn main() -> void { +fn main() { var local_arr : array = array(0.0, 1.0, 2.0, 3.0); var local_str : S = S(1, 2.0, 3); } @@ -240,7 +240,7 @@ struct Uniforms { [[builtin(position)]] var position : vec4; [[stage(vertex)]] -fn main() -> void { +fn main() { const transform : mat2x2 = ubo.transform; var coord : vec2 = array, 3>( vec2(-1.0, 1.0), @@ -264,7 +264,7 @@ struct Uniforms { [[builtin(position)]] var position : vec4; [[stage(vertex)]] -fn main() -> void { +fn main() { const transform : mat2x2 = ubo.transform; const tint_symbol_1 : array, 3> = array, 3>(vec2(-1.0, 1.0), vec2(1.0, 1.0), vec2(-1.0, -1.0)); var coord : vec2 = tint_symbol_1[vertex_index]; @@ -282,7 +282,7 @@ TEST_F(HlslTest, AddEmptyEntryPoint) { auto* expect = R"( [[stage(vertex)]] -fn _tint_unused_entry_point() -> void { +fn _tint_unused_entry_point() { } )"; diff --git a/src/transform/msl_test.cc b/src/transform/msl_test.cc index 7bf1931478..e144f78863 100644 --- a/src/transform/msl_test.cc +++ b/src/transform/msl_test.cc @@ -31,7 +31,7 @@ struct class { }; [[stage(fragment)]] -fn main() -> void { +fn main() { var foo : i32; var half : f32; var half1 : f32; @@ -46,7 +46,7 @@ struct _tint_class { }; [[stage(fragment)]] -fn _tint_main() -> void { +fn _tint_main() { var foo : i32; var _tint_half : f32; var half1 : f32; @@ -65,7 +65,7 @@ TEST_P(MslReservedKeywordTest, Keywords) { auto src = R"( [[stage(fragment)]] -fn main() -> void { +fn main() { var )" + keyword + R"( : i32; } @@ -73,7 +73,7 @@ fn main() -> void { auto expect = R"( [[stage(fragment)]] -fn _tint_main() -> void { +fn _tint_main() { var _tint_)" + keyword + R"( : i32; } diff --git a/src/transform/renamer_test.cc b/src/transform/renamer_test.cc index add9c84a03..5302ea8c36 100644 --- a/src/transform/renamer_test.cc +++ b/src/transform/renamer_test.cc @@ -47,7 +47,7 @@ fn test() -> u32 { } [[stage(vertex)]] -fn entry() -> void { +fn entry() { test(); } )"; @@ -60,7 +60,7 @@ fn _tint_2() -> u32 { } [[stage(vertex)]] -fn _tint_3() -> void { +fn _tint_3() { _tint_2(); } )"; diff --git a/src/transform/spirv.cc b/src/transform/spirv.cc index a4a07f2c14..427421c78c 100644 --- a/src/transform/spirv.cc +++ b/src/transform/spirv.cc @@ -94,13 +94,13 @@ void Spirv::HandleEntryPointIOTypes(CloneContext& ctx) const { // [[builtin(frag_depth)]] var depth: f32; // [[builtin(sample_mask_out)]] var mask_out : u32; // - // fn frag_main_ret(retval : FragmentOutput) -> void { + // fn frag_main_ret(retval : FragmentOutput) { // depth = reval.depth; // mask_out = retval.mask_out; // } // // [[stage(fragment)]] - // fn frag_main() -> void { + // fn frag_main() { // const samples : FragmentInput(sample_index, sample_mask_in); // var output : FragmentOutput = FragmentOutput(1.0, // samples.sample_mask_in); @@ -194,14 +194,14 @@ void Spirv::HandleSampleMaskBuiltins(CloneContext& ctx) const { // Before: // ``` // [[builtin(sample_mask_out)]] var mask_out : u32; - // fn main() -> void { + // fn main() { // mask_out = 1u; // } // ``` // After: // ``` // [[builtin(sample_mask_out)]] var mask_out : array; - // fn main() -> void { + // fn main() { // mask_out[0] = 1u; // } // ``` diff --git a/src/transform/spirv_test.cc b/src/transform/spirv_test.cc index 6cfeff761d..5c365a5d65 100644 --- a/src/transform/spirv_test.cc +++ b/src/transform/spirv_test.cc @@ -26,13 +26,13 @@ TEST_F(SpirvTest, HandleEntryPointIOTypes_Parameters) { auto* src = R"( [[stage(fragment)]] fn frag_main([[builtin(frag_coord)]] coord : vec4, - [[location(1)]] loc1 : f32) -> void { + [[location(1)]] loc1 : f32) { var col : f32 = (coord.x * loc1); } [[stage(compute)]] fn compute_main([[builtin(local_invocation_id)]] local_id : vec3, - [[builtin(local_invocation_index)]] local_index : u32) -> void { + [[builtin(local_invocation_index)]] local_index : u32) { var id_x : u32 = local_id.x; } )"; @@ -43,7 +43,7 @@ fn compute_main([[builtin(local_invocation_id)]] local_id : vec3, [[location(1)]] var tint_symbol_2 : f32; [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { var col : f32 = (tint_symbol_1.x * tint_symbol_2); } @@ -52,7 +52,7 @@ fn frag_main() -> void { [[builtin(local_invocation_index)]] var tint_symbol_7 : u32; [[stage(compute)]] -fn compute_main() -> void { +fn compute_main() { var id_x : u32 = tint_symbol_6.x; } )"; @@ -67,7 +67,7 @@ TEST_F(SpirvTest, HandleEntryPointIOTypes_Parameter_TypeAlias) { type myf32 = f32; [[stage(fragment)]] -fn frag_main([[location(1)]] loc1 : myf32) -> void { +fn frag_main([[location(1)]] loc1 : myf32) { } )"; @@ -77,7 +77,7 @@ type myf32 = f32; [[location(1)]] var tint_symbol_2 : myf32; [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { } )"; @@ -97,12 +97,12 @@ fn vert_main() -> [[builtin(position)]] vec4 { auto* expect = R"( [[builtin(position)]] var tint_symbol_1 : vec4; -fn tint_symbol_2(tint_symbol_3 : vec4) -> void { +fn tint_symbol_2(tint_symbol_3 : vec4) { tint_symbol_1 = tint_symbol_3; } [[stage(vertex)]] -fn vert_main() -> void { +fn vert_main() { tint_symbol_2(vec4(1.0, 2.0, 3.0, 0.0)); return; } @@ -129,12 +129,12 @@ fn frag_main([[location(0)]] loc_in : u32) -> [[location(0)]] f32 { [[location(0)]] var tint_symbol_2 : f32; -fn tint_symbol_3(tint_symbol_4 : f32) -> void { +fn tint_symbol_3(tint_symbol_4 : f32) { tint_symbol_2 = tint_symbol_4; } [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { if ((tint_symbol_1 > 10u)) { tint_symbol_3(0.5); return; @@ -169,12 +169,12 @@ type myf32 = f32; [[location(0)]] var tint_symbol_3 : myf32; -fn tint_symbol_4(tint_symbol_5 : myf32) -> void { +fn tint_symbol_4(tint_symbol_5 : myf32) { tint_symbol_3 = tint_symbol_5; } [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { if ((tint_symbol_2 > 10u)) { tint_symbol_4(0.5); return; @@ -197,7 +197,7 @@ struct FragmentInput { }; [[stage(fragment)]] -fn frag_main(inputs : FragmentInput) -> void { +fn frag_main(inputs : FragmentInput) { var col : f32 = inputs.coord.x * inputs.value; } )"; @@ -213,7 +213,7 @@ struct FragmentInput { [[location(1)]] var tint_symbol_5 : f32; [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { const tint_symbol_7 : FragmentInput = FragmentInput(tint_symbol_4, tint_symbol_5); var col : f32 = (tint_symbol_7.coord.x * tint_symbol_7.value); } @@ -231,7 +231,7 @@ struct FragmentInput { }; [[stage(fragment)]] -fn frag_main(inputs : FragmentInput) -> void { +fn frag_main(inputs : FragmentInput) { } )"; @@ -243,7 +243,7 @@ struct FragmentInput { [[location(1)]] var tint_symbol_3 : f32; [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { } )"; @@ -279,13 +279,13 @@ struct VertexOutput { [[location(1)]] var tint_symbol_5 : f32; -fn tint_symbol_6(tint_symbol_7 : VertexOutput) -> void { +fn tint_symbol_6(tint_symbol_7 : VertexOutput) { tint_symbol_4 = tint_symbol_7.pos; tint_symbol_5 = tint_symbol_7.value; } [[stage(vertex)]] -fn vert_main() -> void { +fn vert_main() { if (false) { tint_symbol_6(VertexOutput()); return; @@ -322,12 +322,12 @@ struct Interface { [[location(1)]] var tint_symbol_4 : f32; -fn tint_symbol_5(tint_symbol_6 : Interface) -> void { +fn tint_symbol_5(tint_symbol_6 : Interface) { tint_symbol_4 = tint_symbol_6.value; } [[stage(vertex)]] -fn vert_main() -> void { +fn vert_main() { const tint_symbol_8 : Interface = Interface(tint_symbol_3); tint_symbol_5(tint_symbol_8); return; @@ -351,7 +351,7 @@ fn vert_main() -> Interface { } [[stage(fragment)]] -fn frag_main(inputs : Interface) -> void { +fn frag_main(inputs : Interface) { var x : f32 = inputs.value; } )"; @@ -363,12 +363,12 @@ struct Interface { [[location(1)]] var tint_symbol_3 : f32; -fn tint_symbol_4(tint_symbol_5 : Interface) -> void { +fn tint_symbol_4(tint_symbol_5 : Interface) { tint_symbol_3 = tint_symbol_5.value; } [[stage(vertex)]] -fn vert_main() -> void { +fn vert_main() { tint_symbol_4(Interface(42.0)); return; } @@ -376,7 +376,7 @@ fn vert_main() -> void { [[location(1)]] var tint_symbol_7 : f32; [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { const tint_symbol_9 : Interface = Interface(tint_symbol_7); var x : f32 = tint_symbol_9.value; } @@ -425,12 +425,12 @@ struct FragmentOutput { [[location(1)]] var tint_symbol_7 : f32; -fn tint_symbol_8(tint_symbol_9 : FragmentOutput) -> void { +fn tint_symbol_8(tint_symbol_9 : FragmentOutput) { tint_symbol_7 = tint_symbol_9.value; } [[stage(fragment)]] -fn frag_main() -> void { +fn frag_main() { const tint_symbol_11 : FragmentInput = FragmentInput(tint_symbol_5, tint_symbol_6); tint_symbol_8(FragmentOutput((tint_symbol_11.coord.x * tint_symbol_11.value))); return; @@ -467,12 +467,12 @@ struct VertexOutput { [[builtin(position)]] var tint_symbol_4 : vec4; -fn tint_symbol_5(tint_symbol_6 : VertexOutput) -> void { +fn tint_symbol_5(tint_symbol_6 : VertexOutput) { tint_symbol_4 = tint_symbol_6.Position; } [[stage(vertex)]] -fn main() -> void { +fn main() { tint_symbol_5(VertexOutput(vec4())); return; } @@ -492,7 +492,7 @@ TEST_F(SpirvTest, HandleSampleMaskBuiltins_Basic) { [[builtin(sample_mask_out)]] var mask_out : u32; [[stage(fragment)]] -fn main() -> void { +fn main() { mask_out = mask_in; } )"; @@ -505,7 +505,7 @@ fn main() -> void { [[builtin(sample_mask_out)]] var mask_out : array; [[stage(fragment)]] -fn main() -> void { +fn main() { mask_out[0] = mask_in[0]; } )"; @@ -525,12 +525,12 @@ fn filter(mask: u32) -> u32 { return (mask & 3u); } -fn set_mask(input : u32) -> void { +fn set_mask(input : u32) { mask_out = input; } [[stage(fragment)]] -fn main() -> void { +fn main() { set_mask(filter(mask_in)); } )"; @@ -544,12 +544,12 @@ fn filter(mask : u32) -> u32 { return (mask & 3u); } -fn set_mask(input : u32) -> void { +fn set_mask(input : u32) { mask_out[0] = input; } [[stage(fragment)]] -fn main() -> void { +fn main() { set_mask(filter(mask_in[0])); } )"; @@ -564,7 +564,7 @@ TEST_F(SpirvTest, AddEmptyEntryPoint) { auto* expect = R"( [[stage(compute)]] -fn _tint_unused_entry_point() -> void { +fn _tint_unused_entry_point() { } )"; @@ -591,12 +591,12 @@ fn main([[builtin(sample_index)]] sample_index : u32, [[builtin(sample_mask_out)]] var tint_symbol_2 : array; -fn tint_symbol_4(tint_symbol_5 : u32) -> void { +fn tint_symbol_4(tint_symbol_5 : u32) { tint_symbol_2[0] = tint_symbol_5; } [[stage(fragment)]] -fn main() -> void { +fn main() { tint_symbol_4(tint_symbol_1[0]); return; } diff --git a/src/transform/vertex_pulling_test.cc b/src/transform/vertex_pulling_test.cc index a6a16997e0..aea3da9414 100644 --- a/src/transform/vertex_pulling_test.cc +++ b/src/transform/vertex_pulling_test.cc @@ -41,7 +41,7 @@ TEST_F(VertexPullingTest, Error_NoEntryPoint) { TEST_F(VertexPullingTest, Error_InvalidEntryPoint) { auto* src = R"( [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = "error: Vertex stage entry point not found"; @@ -59,7 +59,7 @@ fn main() -> void {} TEST_F(VertexPullingTest, Error_EntryPointWrongStage) { auto* src = R"( [[stage(fragment)]] -fn main() -> void {} +fn main() {} )"; auto* expect = "error: Vertex stage entry point not found"; @@ -77,7 +77,7 @@ fn main() -> void {} TEST_F(VertexPullingTest, BasicModule) { auto* src = R"( [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = R"( @@ -87,7 +87,7 @@ struct TintVertexData { }; [[stage(vertex)]] -fn main() -> void { +fn main() { { var _tint_pulling_pos : u32; } @@ -109,7 +109,7 @@ TEST_F(VertexPullingTest, OneAttribute) { [[location(0)]] var var_a : f32; [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = R"( @@ -125,7 +125,7 @@ struct TintVertexData { var var_a : f32; [[stage(vertex)]] -fn main() -> void { +fn main() { { var _tint_pulling_pos : u32; _tint_pulling_pos = ((_tint_pulling_vertex_index * 4u) + 0u); @@ -151,7 +151,7 @@ TEST_F(VertexPullingTest, OneInstancedAttribute) { [[location(0)]] var var_a : f32; [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = R"( @@ -167,7 +167,7 @@ struct TintVertexData { var var_a : f32; [[stage(vertex)]] -fn main() -> void { +fn main() { { var _tint_pulling_pos : u32; _tint_pulling_pos = ((_tint_pulling_instance_index * 4u) + 0u); @@ -193,7 +193,7 @@ TEST_F(VertexPullingTest, OneAttributeDifferentOutputSet) { [[location(0)]] var var_a : f32; [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = R"( @@ -209,7 +209,7 @@ struct TintVertexData { var var_a : f32; [[stage(vertex)]] -fn main() -> void { +fn main() { { var _tint_pulling_pos : u32; _tint_pulling_pos = ((_tint_pulling_vertex_index * 4u) + 0u); @@ -240,7 +240,7 @@ TEST_F(VertexPullingTest, ExistingVertexIndexAndInstanceIndex) { [[builtin(instance_index)]] var custom_instance_index : u32; [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = R"( @@ -262,7 +262,7 @@ var var_b : f32; [[builtin(instance_index)]] var custom_instance_index : u32; [[stage(vertex)]] -fn main() -> void { +fn main() { { var _tint_pulling_pos : u32; _tint_pulling_pos = ((custom_vertex_index * 4u) + 0u); @@ -301,7 +301,7 @@ TEST_F(VertexPullingTest, TwoAttributesSameBuffer) { [[location(1)]] var var_b : vec4; [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = R"( @@ -319,7 +319,7 @@ var var_a : f32; var var_b : vec4; [[stage(vertex)]] -fn main() -> void { +fn main() { { var _tint_pulling_pos : u32; _tint_pulling_pos = ((_tint_pulling_vertex_index * 16u) + 0u); @@ -351,7 +351,7 @@ TEST_F(VertexPullingTest, FloatVectorAttributes) { [[location(2)]] var var_c : vec4; [[stage(vertex)]] -fn main() -> void {} +fn main() {} )"; auto* expect = R"( @@ -375,7 +375,7 @@ var var_b : vec3; var var_c : vec4; [[stage(vertex)]] -fn main() -> void { +fn main() { { var _tint_pulling_pos : u32; _tint_pulling_pos = ((_tint_pulling_vertex_index * 8u) + 0u); diff --git a/src/writer/hlsl/generator_impl_function_test.cc b/src/writer/hlsl/generator_impl_function_test.cc index 7d702777a9..bfd7f8c474 100644 --- a/src/writer/hlsl/generator_impl_function_test.cc +++ b/src/writer/hlsl/generator_impl_function_test.cc @@ -185,7 +185,7 @@ TEST_F(HlslGeneratorImplTest_Function, // fn vert_main() -> Interface { // return Interface(0.4, 0.6); // } - // fn frag_main(colors : Interface) -> void { + // fn frag_main(colors : Interface) { // const r = colors.col1; // const g = colors.col2; // } @@ -961,12 +961,12 @@ TEST_F(HlslGeneratorImplTest_Function, // [[binding(0), group(0)]] var data : Data; // // [[stage(compute)]] - // fn a() -> void { + // fn a() { // return; // } // // [[stage(compute)]] - // fn b() -> void { + // fn b() { // return; // } diff --git a/src/writer/msl/generator_impl_function_test.cc b/src/writer/msl/generator_impl_function_test.cc index 265ce0a069..c29db72745 100644 --- a/src/writer/msl/generator_impl_function_test.cc +++ b/src/writer/msl/generator_impl_function_test.cc @@ -166,7 +166,7 @@ TEST_F(MslGeneratorImplTest, // fn vert_main() -> Interface { // return Interface(0.4, 0.6); // } - // fn frag_main(colors : Interface) -> void { + // fn frag_main(colors : Interface) { // const r = colors.col1; // const g = colors.col2; // } @@ -790,12 +790,12 @@ TEST_F(MslGeneratorImplTest, // [[binding(0), group(0)]] var data : Data; // // [[stage(compute)]] - // fn a() -> void { + // fn a() { // return; // } // // [[stage(compute)]] - // fn b() -> void { + // fn b() { // return; // } diff --git a/src/writer/spirv/builder_entry_point_test.cc b/src/writer/spirv/builder_entry_point_test.cc index 78248bded6..a4792e7b68 100644 --- a/src/writer/spirv/builder_entry_point_test.cc +++ b/src/writer/spirv/builder_entry_point_test.cc @@ -39,7 +39,7 @@ using BuilderTest = TestHelper; TEST_F(BuilderTest, EntryPoint_Parameters) { // [[stage(fragment)]] // fn frag_main([[builtin(frag_coord)]] coord : vec4, - // [[location(1)]] loc1 : f32) -> void { + // [[location(1)]] loc1 : f32) { // var col : f32 = (coord.x * loc1); // } auto* f32 = ty.f32(); diff --git a/src/writer/spirv/builder_function_test.cc b/src/writer/spirv/builder_function_test.cc index e92680db4b..66d93dcd8b 100644 --- a/src/writer/spirv/builder_function_test.cc +++ b/src/writer/spirv/builder_function_test.cc @@ -196,12 +196,12 @@ TEST_F(BuilderTest, Emit_Multiple_EntryPoint_With_Same_ModuleVar) { // [[binding(0), group(0)]] var data : Data; // // [[stage(compute)]] - // fn a() -> void { + // fn a() { // return; // } // // [[stage(compute)]] - // fn b() -> void { + // fn b() { // return; // } diff --git a/src/writer/spirv/builder_global_variable_test.cc b/src/writer/spirv/builder_global_variable_test.cc index f3f321753b..464b69c5ac 100644 --- a/src/writer/spirv/builder_global_variable_test.cc +++ b/src/writer/spirv/builder_global_variable_test.cc @@ -612,7 +612,7 @@ TEST_F(BuilderTest, SampleMask) { // [[builtin(sample_mask_in)]] var mask_in : u32; // [[builtin(sample_mask_out)]] var mask_out : u32; // [[stage(fragment)]] - // fn main() -> void { + // fn main() { // mask_out = mask_in; // } @@ -620,7 +620,7 @@ TEST_F(BuilderTest, SampleMask) { // [[builtin(sample_mask_in)]] var mask_in : array; // [[builtin(sample_mask_out)]] var mask_out : array; // [[stage(fragment)]] - // fn main() -> void { + // fn main() { // mask_out[0] = mask_in[0]; // } diff --git a/src/writer/wgsl/generator_impl.cc b/src/writer/wgsl/generator_impl.cc index 7187eb821d..6bc841353d 100644 --- a/src/writer/wgsl/generator_impl.cc +++ b/src/writer/wgsl/generator_impl.cc @@ -330,17 +330,22 @@ bool GeneratorImpl::EmitFunction(ast::Function* func) { } } - out_ << ") -> "; + out_ << ")"; - if (!func->return_type_decorations().empty()) { - if (!EmitDecorations(func->return_type_decorations())) { + if (!func->return_type()->Is() || + !func->return_type_decorations().empty()) { + out_ << " -> "; + + if (!func->return_type_decorations().empty()) { + if (!EmitDecorations(func->return_type_decorations())) { + return false; + } + out_ << " "; + } + + if (!EmitType(func->return_type())) { return false; } - out_ << " "; - } - - if (!EmitType(func->return_type())) { - return false; } if (func->body()) { diff --git a/src/writer/wgsl/generator_impl_entry_point_test.cc b/src/writer/wgsl/generator_impl_entry_point_test.cc index e4521dcd3f..886534e7b4 100644 --- a/src/writer/wgsl/generator_impl_entry_point_test.cc +++ b/src/writer/wgsl/generator_impl_entry_point_test.cc @@ -48,11 +48,11 @@ TEST_F(WgslGeneratorImplTest, Emit_EntryPoint_UnusedFunction) { ASSERT_TRUE( gen.GenerateEntryPoint(tint::ast::PipelineStage::kCompute, "main")) << gen.error(); - EXPECT_EQ(gen.result(), R"( fn func_used() -> void { + EXPECT_EQ(gen.result(), R"( fn func_used() { } [[stage(compute)]] - fn main() -> void { + fn main() { func_used(); } )"); @@ -85,7 +85,7 @@ TEST_F(WgslGeneratorImplTest, Emit_EntryPoint_UnusedVariable) { EXPECT_EQ(gen.result(), R"( var global_used : f32; [[stage(compute)]] - fn main() -> void { + fn main() { global_used = 1.0; } )"); @@ -152,7 +152,7 @@ TEST_F(WgslGeneratorImplTest, Emit_EntryPoint_GlobalsInterleaved) { }; [[stage(compute)]] - fn main() -> void { + fn main() { var s0 : S0; var s1 : S1; a1 = func(); diff --git a/src/writer/wgsl/generator_impl_function_test.cc b/src/writer/wgsl/generator_impl_function_test.cc index 9da8478870..f7f6d6a790 100644 --- a/src/writer/wgsl/generator_impl_function_test.cc +++ b/src/writer/wgsl/generator_impl_function_test.cc @@ -39,7 +39,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function) { gen.increment_indent(); ASSERT_TRUE(gen.EmitFunction(func)); - EXPECT_EQ(gen.result(), R"( fn my_func() -> void { + EXPECT_EQ(gen.result(), R"( fn my_func() { discard; return; } @@ -63,7 +63,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithParams) { gen.increment_indent(); ASSERT_TRUE(gen.EmitFunction(func)); - EXPECT_EQ(gen.result(), R"( fn my_func(a : f32, b : i32) -> void { + EXPECT_EQ(gen.result(), R"( fn my_func(a : f32, b : i32) { discard; return; } @@ -86,7 +86,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_WorkgroupSize) { ASSERT_TRUE(gen.EmitFunction(func)); EXPECT_EQ(gen.result(), R"( [[workgroup_size(2, 4, 6)]] - fn my_func() -> void { + fn my_func() { discard; return; } @@ -110,7 +110,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_Stage) { ASSERT_TRUE(gen.EmitFunction(func)); EXPECT_EQ(gen.result(), R"( [[stage(fragment)]] - fn my_func() -> void { + fn my_func() { discard; return; } @@ -136,7 +136,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_WithDecoration_Multiple) { ASSERT_TRUE(gen.EmitFunction(func)); EXPECT_EQ(gen.result(), R"( [[stage(fragment)]] [[workgroup_size(2, 4, 6)]] - fn my_func() -> void { + fn my_func() { discard; return; } @@ -162,7 +162,7 @@ TEST_F(WgslGeneratorImplTest, Emit_Function_EntryPoint_Parameters) { ASSERT_TRUE(gen.EmitFunction(func)); EXPECT_EQ(gen.result(), R"( [[stage(fragment)]] - fn frag_main([[builtin(frag_coord)]] coord : vec4, [[location(1)]] loc1 : f32) -> void { + fn frag_main([[builtin(frag_coord)]] coord : vec4, [[location(1)]] loc1 : f32) { } )"); } @@ -201,12 +201,12 @@ TEST_F(WgslGeneratorImplTest, // [[binding(0), group(0)]] var data : Data; // // [[stage(compute)]] - // fn a() -> void { + // fn a() { // return; // } // // [[stage(compute)]] - // fn b() -> void { + // fn b() { // return; // } @@ -263,13 +263,13 @@ struct Data { Data; [[stage(compute)]] -fn a() -> void { +fn a() { var v : f32 = data.d; return; } [[stage(compute)]] -fn b() -> void { +fn b() { var v : f32 = data.d; return; } diff --git a/src/writer/wgsl/generator_impl_global_decl_test.cc b/src/writer/wgsl/generator_impl_global_decl_test.cc index ddfd70d893..d853fb2f28 100644 --- a/src/writer/wgsl/generator_impl_global_decl_test.cc +++ b/src/writer/wgsl/generator_impl_global_decl_test.cc @@ -36,7 +36,7 @@ TEST_F(WgslGeneratorImplTest, Emit_GlobalDeclAfterFunction) { ASSERT_TRUE(gen.Generate(nullptr)) << gen.error(); EXPECT_EQ(gen.result(), R"( [[stage(compute)]] - fn test_function() -> void { + fn test_function() { var a : f32; } @@ -103,7 +103,7 @@ TEST_F(WgslGeneratorImplTest, Emit_GlobalsInterleaved) { }; [[stage(compute)]] - fn main() -> void { + fn main() { var s0 : S0; var s1 : S1; a1 = func(); diff --git a/src/writer/wgsl/generator_impl_test.cc b/src/writer/wgsl/generator_impl_test.cc index 54645142be..7fc0d61a83 100644 --- a/src/writer/wgsl/generator_impl_test.cc +++ b/src/writer/wgsl/generator_impl_test.cc @@ -29,7 +29,7 @@ TEST_F(WgslGeneratorImplTest, Generate) { GeneratorImpl& gen = Build(); ASSERT_TRUE(gen.Generate(nullptr)) << gen.error(); - EXPECT_EQ(gen.result(), R"(fn my_func() -> void { + EXPECT_EQ(gen.result(), R"(fn my_func() { } )"); } diff --git a/test/compute_boids.wgsl b/test/compute_boids.wgsl index 5ccf6edb54..e68daae6bf 100644 --- a/test/compute_boids.wgsl +++ b/test/compute_boids.wgsl @@ -60,7 +60,7 @@ fn frag_main() -> [[location(0)]] vec4 { // https://github.com/austinEng/Project6-Vulkan-Flocking/blob/master/data/shaders/computeparticles/particle.comp [[stage(compute)]] fn comp_main( - [[builtin(global_invocation_id)]] gl_GlobalInvocationID : vec3) -> void { + [[builtin(global_invocation_id)]] gl_GlobalInvocationID : vec3) { var index : u32 = gl_GlobalInvocationID.x; if (index >= 5u) { return; diff --git a/test/function.wgsl b/test/function.wgsl index 9016ba217c..7a6d6a7350 100644 --- a/test/function.wgsl +++ b/test/function.wgsl @@ -18,5 +18,5 @@ fn main() -> f32 { [[stage(compute)]] [[workgroup_size(2)]] -fn ep() -> void { +fn ep() { } diff --git a/test/simple.wgsl b/test/simple.wgsl index b7d761a645..bec6a0f21d 100644 --- a/test/simple.wgsl +++ b/test/simple.wgsl @@ -12,7 +12,7 @@ // See the License for the specific language governing permissions and // limitations under the License. -fn bar() -> void { +fn bar() { } [[stage(fragment)]] diff --git a/tools/check-spec-examples/main.go b/tools/check-spec-examples/main.go index 7b11323762..f3263e73a9 100644 --- a/tools/check-spec-examples/main.go +++ b/tools/check-spec-examples/main.go @@ -199,7 +199,7 @@ type example struct { func tryCompile(compiler, wd string, e example) error { code := e.code if e.functionScope { - code = "\n[[stage(vertex)]] fn main() -> void {\n" + code + "}\n" + code = "\n[[stage(vertex)]] fn main() {\n" + code + "}\n" } addedStubFunction := false @@ -212,7 +212,7 @@ func tryCompile(compiler, wd string, e example) error { if !addedStubFunction && strings.Contains(err.Error(), "error v-0003") { // error v-0003: At least one of vertex, fragment or compute shader // must be present. Add a stub entry point to satisfy the compiler. - code += "\n[[stage(vertex)]] fn main() -> void {}\n" + code += "\n[[stage(vertex)]] fn main() {}\n" addedStubFunction = true continue }