Update intrinsics in the grammar.
The intrinsic methods were removed from the WGSL grammar and are treated
as builtin functions. This Cl updates Tint to match.
Bug: tint:41
Change-Id: I3f9ff6c17f1ca57ad159d883fd5a966657caeb4f
Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/22301
Reviewed-by: David Neto <dneto@google.com>
diff --git a/BUILD.gn b/BUILD.gn
index 698068f..7c08d05 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -230,8 +230,6 @@
"src/ast/continue_statement.h",
"src/ast/decorated_variable.cc",
"src/ast/decorated_variable.h",
- "src/ast/derivative_modifier.cc",
- "src/ast/derivative_modifier.h",
"src/ast/else_statement.cc",
"src/ast/else_statement.h",
"src/ast/entry_point.cc",
@@ -322,14 +320,6 @@
"src/ast/type_constructor_expression.h",
"src/ast/uint_literal.cc",
"src/ast/uint_literal.h",
- "src/ast/unary_derivative.cc",
- "src/ast/unary_derivative.h",
- "src/ast/unary_derivative_expression.cc",
- "src/ast/unary_derivative_expression.h",
- "src/ast/unary_method.cc",
- "src/ast/unary_method.h",
- "src/ast/unary_method_expression.cc",
- "src/ast/unary_method_expression.h",
"src/ast/unary_op.cc",
"src/ast/unary_op.h",
"src/ast/unary_op_expression.cc",
@@ -623,8 +613,6 @@
"src/ast/type/vector_type_test.cc",
"src/ast/type_constructor_expression_test.cc",
"src/ast/uint_literal_test.cc",
- "src/ast/unary_derivative_expression_test.cc",
- "src/ast/unary_method_expression_test.cc",
"src/ast/unary_op_expression_test.cc",
"src/ast/unless_statement_test.cc",
"src/ast/variable_decl_statement_test.cc",
@@ -737,7 +725,6 @@
"src/reader/wgsl/parser_impl_const_literal_test.cc",
"src/reader/wgsl/parser_impl_continue_stmt_test.cc",
"src/reader/wgsl/parser_impl_continuing_stmt_test.cc",
- "src/reader/wgsl/parser_impl_derivative_modifier_test.cc",
"src/reader/wgsl/parser_impl_else_stmt_test.cc",
"src/reader/wgsl/parser_impl_elseif_stmt_test.cc",
"src/reader/wgsl/parser_impl_entry_point_decl_test.cc",
@@ -830,7 +817,6 @@
"src/writer/wgsl/generator_impl_switch_test.cc",
"src/writer/wgsl/generator_impl_test.cc",
"src/writer/wgsl/generator_impl_type_test.cc",
- "src/writer/wgsl/generator_impl_unary_derivative_test.cc",
"src/writer/wgsl/generator_impl_unary_method_test.cc",
"src/writer/wgsl/generator_impl_unary_op_test.cc",
"src/writer/wgsl/generator_impl_unless_test.cc",
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 22fdd35..117063b 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -67,8 +67,6 @@
ast/continue_statement.h
ast/decorated_variable.cc
ast/decorated_variable.h
- ast/derivative_modifier.cc
- ast/derivative_modifier.h
ast/else_statement.cc
ast/else_statement.h
ast/entry_point.cc
@@ -159,14 +157,6 @@
ast/type/void_type.h
ast/uint_literal.cc
ast/uint_literal.h
- ast/unary_derivative.cc
- ast/unary_derivative.h
- ast/unary_derivative_expression.cc
- ast/unary_derivative_expression.h
- ast/unary_method.cc
- ast/unary_method.h
- ast/unary_method_expression.cc
- ast/unary_method_expression.h
ast/unary_op.cc
ast/unary_op.h
ast/unary_op_expression.cc
@@ -303,8 +293,6 @@
ast/type/vector_type_test.cc
ast/type_constructor_expression_test.cc
ast/uint_literal_test.cc
- ast/unary_derivative_expression_test.cc
- ast/unary_method_expression_test.cc
ast/unary_op_expression_test.cc
ast/unless_statement_test.cc
ast/variable_decl_statement_test.cc
@@ -368,7 +356,6 @@
reader/wgsl/parser_impl_const_literal_test.cc
reader/wgsl/parser_impl_continue_stmt_test.cc
reader/wgsl/parser_impl_continuing_stmt_test.cc
- reader/wgsl/parser_impl_derivative_modifier_test.cc
reader/wgsl/parser_impl_else_stmt_test.cc
reader/wgsl/parser_impl_elseif_stmt_test.cc
reader/wgsl/parser_impl_entry_point_decl_test.cc
@@ -478,8 +465,6 @@
writer/wgsl/generator_impl_return_test.cc
writer/wgsl/generator_impl_switch_test.cc
writer/wgsl/generator_impl_type_test.cc
- writer/wgsl/generator_impl_unary_derivative_test.cc
- writer/wgsl/generator_impl_unary_method_test.cc
writer/wgsl/generator_impl_unary_op_test.cc
writer/wgsl/generator_impl_unless_test.cc
writer/wgsl/generator_impl_variable_decl_statement_test.cc
diff --git a/src/ast/derivative_modifier.cc b/src/ast/derivative_modifier.cc
deleted file mode 100644
index 66a7f35..0000000
--- a/src/ast/derivative_modifier.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/derivative_modifier.h"
-
-namespace tint {
-namespace ast {
-
-std::ostream& operator<<(std::ostream& out, DerivativeModifier mod) {
- switch (mod) {
- case DerivativeModifier::kNone: {
- out << "none";
- break;
- }
- case DerivativeModifier::kFine: {
- out << "fine";
- break;
- }
- case DerivativeModifier::kCoarse: {
- out << "coarse";
- break;
- }
- }
- return out;
-}
-
-} // namespace ast
-} // namespace tint
diff --git a/src/ast/derivative_modifier.h b/src/ast/derivative_modifier.h
deleted file mode 100644
index 83789e4..0000000
--- a/src/ast/derivative_modifier.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AST_DERIVATIVE_MODIFIER_H_
-#define SRC_AST_DERIVATIVE_MODIFIER_H_
-
-#include <ostream>
-
-namespace tint {
-namespace ast {
-
-/// The derivative modifier
-enum class DerivativeModifier { kNone = -1, kFine, kCoarse };
-
-std::ostream& operator<<(std::ostream& out, DerivativeModifier mod);
-
-} // namespace ast
-} // namespace tint
-
-#endif // SRC_AST_DERIVATIVE_MODIFIER_H_
diff --git a/src/ast/expression.cc b/src/ast/expression.cc
index 71074e6..bbbc7ad 100644
--- a/src/ast/expression.cc
+++ b/src/ast/expression.cc
@@ -25,8 +25,6 @@
#include "src/ast/identifier_expression.h"
#include "src/ast/member_accessor_expression.h"
#include "src/ast/type/alias_type.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
namespace tint {
@@ -78,14 +76,6 @@
return false;
}
-bool Expression::IsUnaryDerivative() const {
- return false;
-}
-
-bool Expression::IsUnaryMethod() const {
- return false;
-}
-
bool Expression::IsUnaryOp() const {
return false;
}
@@ -129,16 +119,6 @@
return static_cast<const MemberAccessorExpression*>(this);
}
-const UnaryDerivativeExpression* Expression::AsUnaryDerivative() const {
- assert(IsUnaryDerivative());
- return static_cast<const UnaryDerivativeExpression*>(this);
-}
-
-const UnaryMethodExpression* Expression::AsUnaryMethod() const {
- assert(IsUnaryMethod());
- return static_cast<const UnaryMethodExpression*>(this);
-}
-
const UnaryOpExpression* Expression::AsUnaryOp() const {
assert(IsUnaryOp());
return static_cast<const UnaryOpExpression*>(this);
@@ -184,16 +164,6 @@
return static_cast<MemberAccessorExpression*>(this);
}
-UnaryDerivativeExpression* Expression::AsUnaryDerivative() {
- assert(IsUnaryDerivative());
- return static_cast<UnaryDerivativeExpression*>(this);
-}
-
-UnaryMethodExpression* Expression::AsUnaryMethod() {
- assert(IsUnaryMethod());
- return static_cast<UnaryMethodExpression*>(this);
-}
-
UnaryOpExpression* Expression::AsUnaryOp() {
assert(IsUnaryOp());
return static_cast<UnaryOpExpression*>(this);
diff --git a/src/ast/expression.h b/src/ast/expression.h
index f82fe9b..43c4c40 100644
--- a/src/ast/expression.h
+++ b/src/ast/expression.h
@@ -32,8 +32,6 @@
class IdentifierExpression;
class ConstructorExpression;
class MemberAccessorExpression;
-class UnaryDerivativeExpression;
-class UnaryMethodExpression;
class UnaryOpExpression;
/// Base expression class
@@ -63,10 +61,6 @@
virtual bool IsMemberAccessor() const;
/// @returns true if this is a binary expression
virtual bool IsBinary() const;
- /// @returns true if this is a unary derivative expression
- virtual bool IsUnaryDerivative() const;
- /// @returns true if this is a unary method expression
- virtual bool IsUnaryMethod() const;
/// @returns true if this is a unary op expression
virtual bool IsUnaryOp() const;
@@ -86,10 +80,6 @@
const MemberAccessorExpression* AsMemberAccessor() const;
/// @returns the expression as a binary expression
const BinaryExpression* AsBinary() const;
- /// @returns the expression as a unary derivative expression
- const UnaryDerivativeExpression* AsUnaryDerivative() const;
- /// @returns the expression as a unary method expression
- const UnaryMethodExpression* AsUnaryMethod() const;
/// @returns the expression as a unary op expression
const UnaryOpExpression* AsUnaryOp() const;
@@ -109,10 +99,6 @@
MemberAccessorExpression* AsMemberAccessor();
/// @returns the expression as a binary expression
BinaryExpression* AsBinary();
- /// @returns the expression as a unary derivative expression
- UnaryDerivativeExpression* AsUnaryDerivative();
- /// @returns the expression as a unary method expression
- UnaryMethodExpression* AsUnaryMethod();
/// @returns the expression as a unary op expression
UnaryOpExpression* AsUnaryOp();
diff --git a/src/ast/unary_derivative.cc b/src/ast/unary_derivative.cc
deleted file mode 100644
index 82ae23c..0000000
--- a/src/ast/unary_derivative.cc
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/unary_derivative.h"
-
-namespace tint {
-namespace ast {
-
-std::ostream& operator<<(std::ostream& out, UnaryDerivative mod) {
- switch (mod) {
- case UnaryDerivative::kDpdx: {
- out << "dpdx";
- break;
- }
- case UnaryDerivative::kDpdy: {
- out << "dpdy";
- break;
- }
- case UnaryDerivative::kFwidth: {
- out << "fwidth";
- break;
- }
- }
- return out;
-}
-
-} // namespace ast
-} // namespace tint
diff --git a/src/ast/unary_derivative.h b/src/ast/unary_derivative.h
deleted file mode 100644
index 741834c..0000000
--- a/src/ast/unary_derivative.h
+++ /dev/null
@@ -1,31 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AST_UNARY_DERIVATIVE_H_
-#define SRC_AST_UNARY_DERIVATIVE_H_
-
-#include <ostream>
-
-namespace tint {
-namespace ast {
-
-/// The unary derivative
-enum class UnaryDerivative { kDpdx = 0, kDpdy, kFwidth };
-
-std::ostream& operator<<(std::ostream& out, UnaryDerivative mod);
-
-} // namespace ast
-} // namespace tint
-
-#endif // SRC_AST_UNARY_DERIVATIVE_H_
diff --git a/src/ast/unary_derivative_expression.cc b/src/ast/unary_derivative_expression.cc
deleted file mode 100644
index 23c13d5..0000000
--- a/src/ast/unary_derivative_expression.cc
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/unary_derivative_expression.h"
-
-namespace tint {
-namespace ast {
-
-UnaryDerivativeExpression::UnaryDerivativeExpression() : Expression() {}
-
-UnaryDerivativeExpression::UnaryDerivativeExpression(
- UnaryDerivative op,
- DerivativeModifier mod,
- std::unique_ptr<Expression> param)
- : Expression(), op_(op), modifier_(mod), param_(std::move(param)) {}
-
-UnaryDerivativeExpression::UnaryDerivativeExpression(
- const Source& source,
- UnaryDerivative op,
- DerivativeModifier mod,
- std::unique_ptr<Expression> param)
- : Expression(source), op_(op), modifier_(mod), param_(std::move(param)) {}
-
-UnaryDerivativeExpression::UnaryDerivativeExpression(
- UnaryDerivativeExpression&&) = default;
-
-UnaryDerivativeExpression::~UnaryDerivativeExpression() = default;
-
-bool UnaryDerivativeExpression::IsUnaryDerivative() const {
- return true;
-}
-
-bool UnaryDerivativeExpression::IsValid() const {
- if (param_ == nullptr || !param_->IsValid()) {
- return false;
- }
- return true;
-}
-
-void UnaryDerivativeExpression::to_str(std::ostream& out, size_t indent) const {
- make_indent(out, indent);
- out << "UnaryDerivative{" << std::endl;
- make_indent(out, indent + 2);
- out << op_ << std::endl;
- make_indent(out, indent + 2);
- out << modifier_ << std::endl;
- param_->to_str(out, indent + 2);
- make_indent(out, indent);
- out << "}" << std::endl;
-}
-
-} // namespace ast
-} // namespace tint
diff --git a/src/ast/unary_derivative_expression.h b/src/ast/unary_derivative_expression.h
deleted file mode 100644
index 2076eaf..0000000
--- a/src/ast/unary_derivative_expression.h
+++ /dev/null
@@ -1,96 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AST_UNARY_DERIVATIVE_EXPRESSION_H_
-#define SRC_AST_UNARY_DERIVATIVE_EXPRESSION_H_
-
-#include <memory>
-#include <utility>
-
-#include "src/ast/derivative_modifier.h"
-#include "src/ast/expression.h"
-#include "src/ast/literal.h"
-#include "src/ast/unary_derivative.h"
-
-namespace tint {
-namespace ast {
-
-/// A unary derivative expression
-class UnaryDerivativeExpression : public Expression {
- public:
- /// Constructor
- UnaryDerivativeExpression();
- /// Constructor
- /// @param op the op
- /// @param mod the derivative modifier
- /// @param param the param
- UnaryDerivativeExpression(UnaryDerivative op,
- DerivativeModifier mod,
- std::unique_ptr<Expression> param);
- /// Constructor
- /// @param source the unary derivative expression source
- /// @param op the op
- /// @param mod the derivative modifier
- /// @param param the param
- UnaryDerivativeExpression(const Source& source,
- UnaryDerivative op,
- DerivativeModifier mod,
- std::unique_ptr<Expression> param);
- /// Move constructor
- UnaryDerivativeExpression(UnaryDerivativeExpression&&);
- ~UnaryDerivativeExpression() override;
-
- /// Sets the op
- /// @param op the op
- void set_op(UnaryDerivative op) { op_ = op; }
- /// @returns the op
- UnaryDerivative op() const { return op_; }
-
- /// Sets the derivative modifier
- /// @param mod the modifier
- void set_modifier(DerivativeModifier mod) { modifier_ = mod; }
- /// @returns the derivative modifier
- DerivativeModifier modifier() const { return modifier_; }
-
- /// Sets the param
- /// @param param the param
- void set_param(std::unique_ptr<Expression> param) {
- param_ = std::move(param);
- }
- /// @returns the param
- Expression* param() const { return param_.get(); }
-
- /// @returns true if this is an as expression
- bool IsUnaryDerivative() const override;
-
- /// @returns true if the node is valid
- bool IsValid() const override;
-
- /// Writes a representation of the node to the output stream
- /// @param out the stream to write to
- /// @param indent number of spaces to indent the node when writing
- void to_str(std::ostream& out, size_t indent) const override;
-
- private:
- UnaryDerivativeExpression(const UnaryDerivativeExpression&) = delete;
-
- UnaryDerivative op_ = UnaryDerivative::kDpdx;
- DerivativeModifier modifier_ = DerivativeModifier::kNone;
- std::unique_ptr<Expression> param_;
-};
-
-} // namespace ast
-} // namespace tint
-
-#endif // SRC_AST_UNARY_DERIVATIVE_EXPRESSION_H_
diff --git a/src/ast/unary_derivative_expression_test.cc b/src/ast/unary_derivative_expression_test.cc
deleted file mode 100644
index 96d1e46..0000000
--- a/src/ast/unary_derivative_expression_test.cc
+++ /dev/null
@@ -1,90 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/unary_derivative_expression.h"
-
-#include <sstream>
-
-#include "gtest/gtest.h"
-#include "src/ast/identifier_expression.h"
-
-namespace tint {
-namespace ast {
-namespace {
-
-using UnaryDerivativeExpressionTest = testing::Test;
-
-TEST_F(UnaryDerivativeExpressionTest, Creation) {
- auto ident = std::make_unique<IdentifierExpression>("ident");
- auto* ident_ptr = ident.get();
-
- UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
- DerivativeModifier::kCoarse, std::move(ident));
- EXPECT_EQ(d.param(), ident_ptr);
- EXPECT_EQ(d.modifier(), DerivativeModifier::kCoarse);
- EXPECT_EQ(d.op(), UnaryDerivative::kDpdy);
-}
-
-TEST_F(UnaryDerivativeExpressionTest, Creation_WithSource) {
- auto ident = std::make_unique<IdentifierExpression>("ident");
-
- UnaryDerivativeExpression d(Source{20, 2}, UnaryDerivative::kDpdy,
- DerivativeModifier::kCoarse, std::move(ident));
- auto src = d.source();
- EXPECT_EQ(src.line, 20u);
- EXPECT_EQ(src.column, 2u);
-}
-
-TEST_F(UnaryDerivativeExpressionTest, IsUnaryDerivative) {
- UnaryDerivativeExpression d;
- EXPECT_TRUE(d.IsUnaryDerivative());
-}
-
-TEST_F(UnaryDerivativeExpressionTest, IsValid) {
- auto ident = std::make_unique<IdentifierExpression>("ident");
- UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
- DerivativeModifier::kCoarse, std::move(ident));
- EXPECT_TRUE(d.IsValid());
-}
-
-TEST_F(UnaryDerivativeExpressionTest, IsValid_NullParam) {
- UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
- DerivativeModifier::kCoarse, nullptr);
- EXPECT_FALSE(d.IsValid());
-}
-
-TEST_F(UnaryDerivativeExpressionTest, IsValid_InvalidParam) {
- auto ident = std::make_unique<IdentifierExpression>("");
- UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
- DerivativeModifier::kCoarse, std::move(ident));
- EXPECT_FALSE(d.IsValid());
-}
-
-TEST_F(UnaryDerivativeExpressionTest, ToStr) {
- auto ident = std::make_unique<IdentifierExpression>("ident");
- UnaryDerivativeExpression d(UnaryDerivative::kDpdy,
- DerivativeModifier::kCoarse, std::move(ident));
- std::ostringstream out;
- d.to_str(out, 2);
- EXPECT_EQ(out.str(), R"( UnaryDerivative{
- dpdy
- coarse
- Identifier{ident}
- }
-)");
-}
-
-} // namespace
-} // namespace ast
-} // namespace tint
diff --git a/src/ast/unary_method.cc b/src/ast/unary_method.cc
deleted file mode 100644
index 7ff4653..0000000
--- a/src/ast/unary_method.cc
+++ /dev/null
@@ -1,59 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/unary_method.h"
-
-namespace tint {
-namespace ast {
-
-std::ostream& operator<<(std::ostream& out, UnaryMethod mod) {
- switch (mod) {
- case UnaryMethod::kAny: {
- out << "any";
- break;
- }
- case UnaryMethod::kAll: {
- out << "all";
- break;
- }
- case UnaryMethod::kIsNan: {
- out << "is_nan";
- break;
- }
- case UnaryMethod::kIsInf: {
- out << "is_inf";
- break;
- }
- case UnaryMethod::kIsFinite: {
- out << "is_finite";
- break;
- }
- case UnaryMethod::kIsNormal: {
- out << "is_normal";
- break;
- }
- case UnaryMethod::kDot: {
- out << "dot";
- break;
- }
- case UnaryMethod::kOuterProduct: {
- out << "outer_product";
- break;
- }
- }
- return out;
-}
-
-} // namespace ast
-} // namespace tint
diff --git a/src/ast/unary_method.h b/src/ast/unary_method.h
deleted file mode 100644
index 3f719ef..0000000
--- a/src/ast/unary_method.h
+++ /dev/null
@@ -1,40 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AST_UNARY_METHOD_H_
-#define SRC_AST_UNARY_METHOD_H_
-
-#include <ostream>
-
-namespace tint {
-namespace ast {
-
-/// The unary methods
-enum class UnaryMethod {
- kAny = 0,
- kAll,
- kIsNan,
- kIsInf,
- kIsFinite,
- kIsNormal,
- kDot,
- kOuterProduct
-};
-
-std::ostream& operator<<(std::ostream& out, UnaryMethod mod);
-
-} // namespace ast
-} // namespace tint
-
-#endif // SRC_AST_UNARY_METHOD_H_
diff --git a/src/ast/unary_method_expression.cc b/src/ast/unary_method_expression.cc
deleted file mode 100644
index 034a8e4..0000000
--- a/src/ast/unary_method_expression.cc
+++ /dev/null
@@ -1,65 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/unary_method_expression.h"
-
-namespace tint {
-namespace ast {
-
-UnaryMethodExpression::UnaryMethodExpression() : Expression() {}
-
-UnaryMethodExpression::UnaryMethodExpression(UnaryMethod op,
- ExpressionList params)
- : Expression(), op_(op), params_(std::move(params)) {}
-
-UnaryMethodExpression::UnaryMethodExpression(const Source& source,
- UnaryMethod op,
- ExpressionList params)
- : Expression(source), op_(op), params_(std::move(params)) {}
-
-UnaryMethodExpression::UnaryMethodExpression(UnaryMethodExpression&&) = default;
-
-UnaryMethodExpression::~UnaryMethodExpression() = default;
-
-bool UnaryMethodExpression::IsUnaryMethod() const {
- return true;
-}
-
-bool UnaryMethodExpression::IsValid() const {
- if (params_.empty()) {
- return false;
- }
- for (const auto& p : params_) {
- if (p == nullptr || !p->IsValid()) {
- return false;
- }
- }
- return true;
-}
-
-void UnaryMethodExpression::to_str(std::ostream& out, size_t indent) const {
- make_indent(out, indent);
-
- out << "UnaryMethod{" << std::endl;
- make_indent(out, indent + 2);
- out << op_ << std::endl;
- for (const auto& param : params_) {
- param->to_str(out, indent + 2);
- }
- make_indent(out, indent);
- out << "}" << std::endl;
-}
-
-} // namespace ast
-} // namespace tint
diff --git a/src/ast/unary_method_expression.h b/src/ast/unary_method_expression.h
deleted file mode 100644
index 4c63325..0000000
--- a/src/ast/unary_method_expression.h
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#ifndef SRC_AST_UNARY_METHOD_EXPRESSION_H_
-#define SRC_AST_UNARY_METHOD_EXPRESSION_H_
-
-#include <utility>
-
-#include "src/ast/expression.h"
-#include "src/ast/literal.h"
-#include "src/ast/unary_method.h"
-
-namespace tint {
-namespace ast {
-
-/// A unary method expression
-class UnaryMethodExpression : public Expression {
- public:
- /// Constructor
- UnaryMethodExpression();
- /// Constructor
- /// @param op the op
- /// @param params the params
- UnaryMethodExpression(UnaryMethod op, ExpressionList params);
- /// Constructor
- /// @param source the unary method source
- /// @param op the op
- /// @param params the params
- UnaryMethodExpression(const Source& source,
- UnaryMethod op,
- ExpressionList params);
- /// Move constructor
- UnaryMethodExpression(UnaryMethodExpression&&);
- ~UnaryMethodExpression() override;
-
- /// Sets the op
- /// @param op the op
- void set_op(UnaryMethod op) { op_ = op; }
- /// @returns the op
- UnaryMethod op() const { return op_; }
-
- /// Sets the params
- /// @param params the parameters
- void set_params(ExpressionList params) { params_ = std::move(params); }
- /// @returns the params
- const ExpressionList& params() const { return params_; }
-
- /// @returns true if this is an as expression
- bool IsUnaryMethod() const override;
-
- /// @returns true if the node is valid
- bool IsValid() const override;
-
- /// Writes a representation of the node to the output stream
- /// @param out the stream to write to
- /// @param indent number of spaces to indent the node when writing
- void to_str(std::ostream& out, size_t indent) const override;
-
- private:
- UnaryMethodExpression(const UnaryMethodExpression&) = delete;
-
- UnaryMethod op_ = UnaryMethod::kAny;
- ExpressionList params_;
-};
-
-} // namespace ast
-} // namespace tint
-
-#endif // SRC_AST_UNARY_METHOD_EXPRESSION_H_
diff --git a/src/ast/unary_method_expression_test.cc b/src/ast/unary_method_expression_test.cc
deleted file mode 100644
index 1a2d9ed..0000000
--- a/src/ast/unary_method_expression_test.cc
+++ /dev/null
@@ -1,103 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "src/ast/unary_method_expression.h"
-
-#include <memory>
-#include <sstream>
-
-#include "gtest/gtest.h"
-#include "src/ast/identifier_expression.h"
-
-namespace tint {
-namespace ast {
-namespace {
-
-using UnaryMethodExpressionTest = testing::Test;
-
-TEST_F(UnaryMethodExpressionTest, Creation) {
- ExpressionList params;
- params.push_back(std::make_unique<IdentifierExpression>("ident"));
-
- auto* ident_ptr = params[0].get();
-
- UnaryMethodExpression u(UnaryMethod::kAll, std::move(params));
- EXPECT_EQ(u.op(), UnaryMethod::kAll);
- ASSERT_EQ(u.params().size(), 1u);
- EXPECT_EQ(u.params()[0].get(), ident_ptr);
-}
-
-TEST_F(UnaryMethodExpressionTest, Creation_WithSource) {
- ExpressionList params;
- params.push_back(std::make_unique<IdentifierExpression>("ident"));
-
- UnaryMethodExpression u(Source{20, 2}, UnaryMethod::kAll, std::move(params));
- auto src = u.source();
- EXPECT_EQ(src.line, 20u);
- EXPECT_EQ(src.column, 2u);
-}
-
-TEST_F(UnaryMethodExpressionTest, IsUnaryMethod) {
- UnaryMethodExpression u;
- EXPECT_TRUE(u.IsUnaryMethod());
-}
-
-TEST_F(UnaryMethodExpressionTest, IsValid) {
- ExpressionList params;
- params.push_back(std::make_unique<IdentifierExpression>("ident"));
-
- UnaryMethodExpression u(UnaryMethod::kAll, std::move(params));
- EXPECT_TRUE(u.IsValid());
-}
-
-TEST_F(UnaryMethodExpressionTest, IsValid_NullParam) {
- ExpressionList params;
- params.push_back(std::make_unique<IdentifierExpression>("ident"));
- params.push_back(nullptr);
-
- UnaryMethodExpression u(UnaryMethod::kAll, std::move(params));
- EXPECT_FALSE(u.IsValid());
-}
-
-TEST_F(UnaryMethodExpressionTest, IsValid_InvalidParam) {
- ExpressionList params;
- params.push_back(std::make_unique<IdentifierExpression>(""));
-
- UnaryMethodExpression u(UnaryMethod::kAll, std::move(params));
- EXPECT_FALSE(u.IsValid());
-}
-
-TEST_F(UnaryMethodExpressionTest, IsValid_EmptyParams) {
- UnaryMethodExpression u;
- u.set_op(UnaryMethod::kAll);
- EXPECT_FALSE(u.IsValid());
-}
-
-TEST_F(UnaryMethodExpressionTest, ToStr) {
- ExpressionList params;
- params.push_back(std::make_unique<IdentifierExpression>("ident"));
-
- UnaryMethodExpression u(UnaryMethod::kAll, std::move(params));
- std::ostringstream out;
- u.to_str(out, 2);
- EXPECT_EQ(out.str(), R"( UnaryMethod{
- all
- Identifier{ident}
- }
-)");
-}
-
-} // namespace
-} // namespace ast
-} // namespace tint
diff --git a/src/reader/wgsl/lexer.cc b/src/reader/wgsl/lexer.cc
index 5d11237..ae3e67f 100644
--- a/src/reader/wgsl/lexer.cc
+++ b/src/reader/wgsl/lexer.cc
@@ -468,10 +468,6 @@
}
Token Lexer::check_keyword(const Source& source, const std::string& str) {
- if (str == "all")
- return {Token::Type::kAll, source, "all"};
- if (str == "any")
- return {Token::Type::kAny, source, "any"};
if (str == "array")
return {Token::Type::kArray, source, "array"};
if (str == "as")
@@ -498,16 +494,8 @@
return {Token::Type::kContinue, source, "continue"};
if (str == "continuing")
return {Token::Type::kContinuing, source, "continuing"};
- if (str == "coarse")
- return {Token::Type::kCoarse, source, "coarse"};
if (str == "default")
return {Token::Type::kDefault, source, "default"};
- if (str == "dot")
- return {Token::Type::kDot, source, "dot"};
- if (str == "dpdx")
- return {Token::Type::kDpdx, source, "dpdx"};
- if (str == "dpdy")
- return {Token::Type::kDpdy, source, "dpdy"};
if (str == "else")
return {Token::Type::kElse, source, "else"};
if (str == "elseif")
@@ -520,16 +508,12 @@
return {Token::Type::kFallthrough, source, "fallthrough"};
if (str == "false")
return {Token::Type::kFalse, source, "false"};
- if (str == "fine")
- return {Token::Type::kFine, source, "fine"};
if (str == "fn")
return {Token::Type::kFn, source, "fn"};
if (str == "fragment")
return {Token::Type::kFragment, source, "fragment"};
if (str == "function")
return {Token::Type::kFunction, source, "function"};
- if (str == "fwidth")
- return {Token::Type::kFwidth, source, "fwidth"};
if (str == "i32")
return {Token::Type::kI32, source, "i32"};
if (str == "if")
@@ -540,14 +524,6 @@
return {Token::Type::kImport, source, "import"};
if (str == "in")
return {Token::Type::kIn, source, "in"};
- if (str == "is_nan")
- return {Token::Type::kIsNan, source, "is_nan"};
- if (str == "is_inf")
- return {Token::Type::kIsInf, source, "is_inf"};
- if (str == "is_finite")
- return {Token::Type::kIsFinite, source, "is_finite"};
- if (str == "is_normal")
- return {Token::Type::kIsNormal, source, "is_normal"};
if (str == "kill")
return {Token::Type::kKill, source, "kill"};
if (str == "location")
@@ -576,8 +552,6 @@
return {Token::Type::kOffset, source, "offset"};
if (str == "out")
return {Token::Type::kOut, source, "out"};
- if (str == "outer_product")
- return {Token::Type::kOuterProduct, source, "outer_product"};
if (str == "private")
return {Token::Type::kPrivate, source, "private"};
if (str == "ptr")
diff --git a/src/reader/wgsl/lexer_test.cc b/src/reader/wgsl/lexer_test.cc
index 0b514f9..12170dc 100644
--- a/src/reader/wgsl/lexer_test.cc
+++ b/src/reader/wgsl/lexer_test.cc
@@ -408,82 +408,69 @@
INSTANTIATE_TEST_SUITE_P(
LexerTest,
KeywordTest,
- testing::Values(
- TokenData{"all", Token::Type::kAll},
- TokenData{"any", Token::Type::kAny},
- TokenData{"array", Token::Type::kArray},
- TokenData{"as", Token::Type::kAs},
- TokenData{"binding", Token::Type::kBinding},
- TokenData{"block", Token::Type::kBlock},
- TokenData{"bool", Token::Type::kBool},
- TokenData{"break", Token::Type::kBreak},
- TokenData{"builtin", Token::Type::kBuiltin},
- TokenData{"case", Token::Type::kCase},
- TokenData{"cast", Token::Type::kCast},
- TokenData{"compute", Token::Type::kCompute},
- TokenData{"const", Token::Type::kConst},
- TokenData{"continue", Token::Type::kContinue},
- TokenData{"continuing", Token::Type::kContinuing},
- TokenData{"coarse", Token::Type::kCoarse},
- TokenData{"default", Token::Type::kDefault},
- TokenData{"dot", Token::Type::kDot},
- TokenData{"dpdx", Token::Type::kDpdx},
- TokenData{"dpdy", Token::Type::kDpdy},
- TokenData{"else", Token::Type::kElse},
- TokenData{"elseif", Token::Type::kElseIf},
- TokenData{"entry_point", Token::Type::kEntryPoint},
- TokenData{"f32", Token::Type::kF32},
- TokenData{"fallthrough", Token::Type::kFallthrough},
- TokenData{"false", Token::Type::kFalse},
- TokenData{"fine", Token::Type::kFine},
- TokenData{"fn", Token::Type::kFn},
- TokenData{"fragment", Token::Type::kFragment},
- TokenData{"function", Token::Type::kFunction},
- TokenData{"fwidth", Token::Type::kFwidth},
- TokenData{"i32", Token::Type::kI32},
- TokenData{"if", Token::Type::kIf},
- TokenData{"image", Token::Type::kImage},
- TokenData{"import", Token::Type::kImport},
- TokenData{"in", Token::Type::kIn},
- TokenData{"is_nan", Token::Type::kIsNan},
- TokenData{"is_inf", Token::Type::kIsInf},
- TokenData{"is_finite", Token::Type::kIsFinite},
- TokenData{"is_normal", Token::Type::kIsNormal},
- TokenData{"kill", Token::Type::kKill},
- TokenData{"location", Token::Type::kLocation},
- TokenData{"loop", Token::Type::kLoop},
- TokenData{"mat2x2", Token::Type::kMat2x2},
- TokenData{"mat2x3", Token::Type::kMat2x3},
- TokenData{"mat2x4", Token::Type::kMat2x4},
- TokenData{"mat3x2", Token::Type::kMat3x2},
- TokenData{"mat3x3", Token::Type::kMat3x3},
- TokenData{"mat3x4", Token::Type::kMat3x4},
- TokenData{"mat4x2", Token::Type::kMat4x2},
- TokenData{"mat4x3", Token::Type::kMat4x3},
- TokenData{"mat4x4", Token::Type::kMat4x4},
- TokenData{"offset", Token::Type::kOffset},
- TokenData{"out", Token::Type::kOut},
- TokenData{"outer_product", Token::Type::kOuterProduct},
- TokenData{"private", Token::Type::kPrivate},
- TokenData{"ptr", Token::Type::kPtr},
- TokenData{"return", Token::Type::kReturn},
- TokenData{"set", Token::Type::kSet},
- TokenData{"storage_buffer", Token::Type::kStorageBuffer},
- TokenData{"struct", Token::Type::kStruct},
- TokenData{"switch", Token::Type::kSwitch},
- TokenData{"true", Token::Type::kTrue},
- TokenData{"type", Token::Type::kType},
- TokenData{"u32", Token::Type::kU32},
- TokenData{"uniform", Token::Type::kUniform},
- TokenData{"uniform_constant", Token::Type::kUniformConstant},
- TokenData{"unless", Token::Type::kUnless},
- TokenData{"var", Token::Type::kVar},
- TokenData{"vec2", Token::Type::kVec2},
- TokenData{"vec3", Token::Type::kVec3},
- TokenData{"vec4", Token::Type::kVec4},
- TokenData{"vertex", Token::Type::kVertex},
- TokenData{"void", Token::Type::kVoid},
- TokenData{"workgroup", Token::Type::kWorkgroup}));
+ testing::Values(TokenData{"array", Token::Type::kArray},
+ TokenData{"as", Token::Type::kAs},
+ TokenData{"binding", Token::Type::kBinding},
+ TokenData{"block", Token::Type::kBlock},
+ TokenData{"bool", Token::Type::kBool},
+ TokenData{"break", Token::Type::kBreak},
+ TokenData{"builtin", Token::Type::kBuiltin},
+ TokenData{"case", Token::Type::kCase},
+ TokenData{"cast", Token::Type::kCast},
+ TokenData{"compute", Token::Type::kCompute},
+ TokenData{"const", Token::Type::kConst},
+ TokenData{"continue", Token::Type::kContinue},
+ TokenData{"continuing", Token::Type::kContinuing},
+ TokenData{"default", Token::Type::kDefault},
+ TokenData{"else", Token::Type::kElse},
+ TokenData{"elseif", Token::Type::kElseIf},
+ TokenData{"entry_point", Token::Type::kEntryPoint},
+ TokenData{"f32", Token::Type::kF32},
+ TokenData{"fallthrough", Token::Type::kFallthrough},
+ TokenData{"false", Token::Type::kFalse},
+ TokenData{"fn", Token::Type::kFn},
+ TokenData{"fragment", Token::Type::kFragment},
+ TokenData{"function", Token::Type::kFunction},
+ TokenData{"i32", Token::Type::kI32},
+ TokenData{"if", Token::Type::kIf},
+ TokenData{"image", Token::Type::kImage},
+ TokenData{"import", Token::Type::kImport},
+ TokenData{"in", Token::Type::kIn},
+ TokenData{"kill", Token::Type::kKill},
+ TokenData{"location", Token::Type::kLocation},
+ TokenData{"loop", Token::Type::kLoop},
+ TokenData{"mat2x2", Token::Type::kMat2x2},
+ TokenData{"mat2x3", Token::Type::kMat2x3},
+ TokenData{"mat2x4", Token::Type::kMat2x4},
+ TokenData{"mat3x2", Token::Type::kMat3x2},
+ TokenData{"mat3x3", Token::Type::kMat3x3},
+ TokenData{"mat3x4", Token::Type::kMat3x4},
+ TokenData{"mat4x2", Token::Type::kMat4x2},
+ TokenData{"mat4x3", Token::Type::kMat4x3},
+ TokenData{"mat4x4", Token::Type::kMat4x4},
+ TokenData{"offset", Token::Type::kOffset},
+ TokenData{"out", Token::Type::kOut},
+ TokenData{"private", Token::Type::kPrivate},
+ TokenData{"ptr", Token::Type::kPtr},
+ TokenData{"return", Token::Type::kReturn},
+ TokenData{"set", Token::Type::kSet},
+ TokenData{"storage_buffer", Token::Type::kStorageBuffer},
+ TokenData{"struct", Token::Type::kStruct},
+ TokenData{"switch", Token::Type::kSwitch},
+ TokenData{"true", Token::Type::kTrue},
+ TokenData{"type", Token::Type::kType},
+ TokenData{"u32", Token::Type::kU32},
+ TokenData{"uniform", Token::Type::kUniform},
+ TokenData{"uniform_constant",
+ Token::Type::kUniformConstant},
+ TokenData{"unless", Token::Type::kUnless},
+ TokenData{"var", Token::Type::kVar},
+ TokenData{"vec2", Token::Type::kVec2},
+ TokenData{"vec3", Token::Type::kVec3},
+ TokenData{"vec4", Token::Type::kVec4},
+ TokenData{"vertex", Token::Type::kVertex},
+ TokenData{"void", Token::Type::kVoid},
+ TokenData{"workgroup", Token::Type::kWorkgroup}));
using KeywordTest_Reserved = testing::TestWithParam<const char*>;
TEST_P(KeywordTest_Reserved, Parses) {
diff --git a/src/reader/wgsl/parser_impl.cc b/src/reader/wgsl/parser_impl.cc
index 0cfd6e5..589e4f7 100644
--- a/src/reader/wgsl/parser_impl.cc
+++ b/src/reader/wgsl/parser_impl.cc
@@ -57,10 +57,6 @@
#include "src/ast/type/void_type.h"
#include "src/ast/type_constructor_expression.h"
#include "src/ast/uint_literal.h"
-#include "src/ast/unary_derivative.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op.h"
#include "src/ast/unary_op_expression.h"
#include "src/ast/variable_decl_statement.h"
@@ -2338,30 +2334,6 @@
// : postfix_expression
// | MINUS unary_expression
// | BANG unary_expression
-// | ANY PAREN_LEFT IDENT PAREN_RIGHT
-// | ALL PAREN_LEFT IDENT PAREN_RIGHT
-// | IS_NAN PAREN_LEFT IDENT PAREN_RIGHT
-// | IS_INF PAREN_LEFT IDENT PAREN_RIGHT
-// | IS_FINITE PAREN_LEFT IDENT PAREN_RIGHT
-// | IS_NORMAL PAREN_LEFT IDENT PAREN_RIGHT
-// | DOT PAREN_LEFT IDENT COMMA IDENT PAREN_RIGHT
-// | OUTER_PRODUCT PAREN_LEFT IDENT COMMA IDENT PAREN_RIGHT
-// | DPDX (LESS_THAN derivative_modifier GREATER_THAN)?
-// PAREN_LEFT IDENT PAREN_RIGHT
-// | DPDY (LESS_THAN derivative_modifier GREATER_THAN)?
-// PAREN_LEFT IDENT PAREN_RIGHT
-// | FWIDTH (LESS_THAN derivative_modifier GREATER_THAN)?
-// PAREN_LEFT IDENT PAREN_RIGHT
-// # | unord_greater_than_equal(a, b)
-// # | unord_greater_than(a, b)
-// # | unord_less_than_equal(a, b)
-// # | unord_less_than(a, b)
-// # | unord_not_equal(a, b)
-// # | unord_equal(a, b)
-// # | signed_greater_than_equal(a, b)
-// # | signed_greater_than(a, b)
-// # | signed_less_than_equal(a, b)
-// # | signed_less_than(a, b)
std::unique_ptr<ast::Expression> ParserImpl::unary_expression() {
auto t = peek();
auto source = t.source();
@@ -2385,158 +2357,9 @@
return std::make_unique<ast::UnaryOpExpression>(source, op,
std::move(expr));
}
- if (t.IsAny() || t.IsAll() || t.IsIsNan() || t.IsIsInf() || t.IsIsFinite() ||
- t.IsIsNormal()) {
- next(); // Consume the peek
-
- auto op = ast::UnaryMethod::kAny;
- if (t.IsAll())
- op = ast::UnaryMethod::kAll;
- else if (t.IsIsNan())
- op = ast::UnaryMethod::kIsNan;
- else if (t.IsIsInf())
- op = ast::UnaryMethod::kIsInf;
- else if (t.IsIsFinite())
- op = ast::UnaryMethod::kIsFinite;
- else if (t.IsIsNormal())
- op = ast::UnaryMethod::kIsNormal;
-
- t = next();
- if (!t.IsParenLeft()) {
- set_error(t, "missing ( for method call");
- return nullptr;
- }
-
- t = next();
- if (!t.IsIdentifier()) {
- set_error(t, "missing identifier for method call");
- return nullptr;
- }
- ast::ExpressionList ident;
- ident.push_back(
- std::make_unique<ast::IdentifierExpression>(source, t.to_str()));
-
- t = next();
- if (!t.IsParenRight()) {
- set_error(t, "missing ) for method call");
- return nullptr;
- }
- return std::make_unique<ast::UnaryMethodExpression>(source, op,
- std::move(ident));
- }
- if (t.IsDot() || t.IsOuterProduct()) {
- next(); // Consume the peek
-
- auto op = ast::UnaryMethod::kDot;
- if (t.IsOuterProduct())
- op = ast::UnaryMethod::kOuterProduct;
-
- t = next();
- if (!t.IsParenLeft()) {
- set_error(t, "missing ( for method call");
- return nullptr;
- }
-
- t = next();
- if (!t.IsIdentifier()) {
- set_error(t, "missing identifier for method call");
- return nullptr;
- }
- ast::ExpressionList ident;
- ident.push_back(
- std::make_unique<ast::IdentifierExpression>(source, t.to_str()));
-
- t = next();
- if (!t.IsComma()) {
- set_error(t, "missing , for method call");
- return nullptr;
- }
-
- t = next();
- if (!t.IsIdentifier()) {
- set_error(t, "missing identifier for method call");
- return nullptr;
- }
- ident.push_back(
- std::make_unique<ast::IdentifierExpression>(source, t.to_str()));
-
- t = next();
- if (!t.IsParenRight()) {
- set_error(t, "missing ) for method call");
- return nullptr;
- }
-
- return std::make_unique<ast::UnaryMethodExpression>(source, op,
- std::move(ident));
- }
- if (t.IsDpdx() || t.IsDpdy() || t.IsFwidth()) {
- next(); // Consume the peek
-
- auto op = ast::UnaryDerivative::kDpdx;
- if (t.IsDpdy())
- op = ast::UnaryDerivative::kDpdy;
- else if (t.IsFwidth())
- op = ast::UnaryDerivative::kFwidth;
-
- t = next();
- auto mod = ast::DerivativeModifier::kNone;
- if (t.IsLessThan()) {
- mod = derivative_modifier();
- if (has_error())
- return nullptr;
- if (mod == ast::DerivativeModifier::kNone) {
- set_error(peek(), "unable to parse derivative modifier");
- return nullptr;
- }
-
- t = next();
- if (!t.IsGreaterThan()) {
- set_error(t, "missing > for derivative modifier");
- return nullptr;
- }
- t = next();
- }
- if (!t.IsParenLeft()) {
- set_error(t, "missing ( for derivative method");
- return nullptr;
- }
-
- t = next();
- if (!t.IsIdentifier()) {
- set_error(t, "missing identifier for derivative method");
- return nullptr;
- }
- auto ident =
- std::make_unique<ast::IdentifierExpression>(source, t.to_str());
-
- t = next();
- if (!t.IsParenRight()) {
- set_error(t, "missing ) for derivative method");
- return nullptr;
- }
-
- return std::make_unique<ast::UnaryDerivativeExpression>(source, op, mod,
- std::move(ident));
- }
return postfix_expression();
}
-// derivative_modifier
-// : FINE
-// | COARSE
-ast::DerivativeModifier ParserImpl::derivative_modifier() {
- auto t = peek();
- if (t.IsFine()) {
- next(); // Consume the peek
- return ast::DerivativeModifier::kFine;
- }
- if (t.IsCoarse()) {
- next(); // Consume the peek
- return ast::DerivativeModifier::kCoarse;
- }
- return ast::DerivativeModifier::kNone;
-}
-
// multiplicative_expr
// :
// | STAR unary_expression multiplicative_expr
diff --git a/src/reader/wgsl/parser_impl.h b/src/reader/wgsl/parser_impl.h
index 3767686..fc88037 100644
--- a/src/reader/wgsl/parser_impl.h
+++ b/src/reader/wgsl/parser_impl.h
@@ -24,7 +24,6 @@
#include "src/ast/assignment_statement.h"
#include "src/ast/builtin.h"
#include "src/ast/constructor_expression.h"
-#include "src/ast/derivative_modifier.h"
#include "src/ast/else_statement.h"
#include "src/ast/entry_point.h"
#include "src/ast/function.h"
@@ -246,9 +245,6 @@
/// Parses a `unary_expression` grammar element
/// @returns the parsed expression or nullptr
std::unique_ptr<ast::Expression> unary_expression();
- /// Parses a `derivative_modifier` grammar element
- /// @returns the modifier or DerivativeModifier::kNone if none matched
- ast::DerivativeModifier derivative_modifier();
/// Parses the recursive part of the `multiplicative_expression`
/// @param lhs the left side of the expression
/// @returns the parsed expression or nullptr
diff --git a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
index 4061b11..efbd731 100644
--- a/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
+++ b/src/reader/wgsl/parser_impl_argument_expression_list_test.cc
@@ -17,8 +17,6 @@
#include "src/ast/identifier_expression.h"
#include "src/ast/int_literal.h"
#include "src/ast/scalar_constructor_expression.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/reader/wgsl/parser_impl.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
diff --git a/src/reader/wgsl/parser_impl_derivative_modifier_test.cc b/src/reader/wgsl/parser_impl_derivative_modifier_test.cc
deleted file mode 100644
index 29b5785e..0000000
--- a/src/reader/wgsl/parser_impl_derivative_modifier_test.cc
+++ /dev/null
@@ -1,86 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include "gtest/gtest.h"
-#include "src/ast/derivative_modifier.h"
-#include "src/reader/wgsl/parser_impl.h"
-#include "src/reader/wgsl/parser_impl_test_helper.h"
-
-namespace tint {
-namespace reader {
-namespace wgsl {
-namespace {
-
-struct DerivativeModifierData {
- const char* input;
- ast::DerivativeModifier result;
-};
-inline std::ostream& operator<<(std::ostream& out,
- DerivativeModifierData data) {
- out << std::string(data.input);
- return out;
-}
-
-class DerivativeModifierTest
- : public testing::TestWithParam<DerivativeModifierData> {
- public:
- DerivativeModifierTest() = default;
- ~DerivativeModifierTest() override = default;
-
- void SetUp() override { ctx_.Reset(); }
-
- void TearDown() override { impl_ = nullptr; }
-
- ParserImpl* parser(const std::string& str) {
- impl_ = std::make_unique<ParserImpl>(&ctx_, str);
- return impl_.get();
- }
-
- private:
- std::unique_ptr<ParserImpl> impl_;
- Context ctx_;
-};
-
-TEST_P(DerivativeModifierTest, Parses) {
- auto params = GetParam();
- auto* p = parser(params.input);
-
- auto mod = p->derivative_modifier();
- ASSERT_FALSE(p->has_error());
- EXPECT_EQ(mod, params.result);
-
- auto t = p->next();
- EXPECT_TRUE(t.IsEof());
-}
-INSTANTIATE_TEST_SUITE_P(
- ParserImplTest,
- DerivativeModifierTest,
- testing::Values(
- DerivativeModifierData{"fine", ast::DerivativeModifier::kFine},
- DerivativeModifierData{"coarse", ast::DerivativeModifier::kCoarse}));
-
-TEST_F(ParserImplTest, DerivativeModifier_NoMatch) {
- auto* p = parser("not-a-modifier");
- auto stage = p->derivative_modifier();
- ASSERT_EQ(stage, ast::DerivativeModifier::kNone);
-
- auto t = p->next();
- EXPECT_TRUE(t.IsIdentifier());
- EXPECT_EQ(t.to_str(), "not");
-}
-
-} // namespace
-} // namespace wgsl
-} // namespace reader
-} // namespace tint
diff --git a/src/reader/wgsl/parser_impl_postfix_expression_test.cc b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
index 6f9ff51..960bdf3 100644
--- a/src/reader/wgsl/parser_impl_postfix_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_postfix_expression_test.cc
@@ -19,8 +19,6 @@
#include "src/ast/int_literal.h"
#include "src/ast/member_accessor_expression.h"
#include "src/ast/scalar_constructor_expression.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/reader/wgsl/parser_impl.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
diff --git a/src/reader/wgsl/parser_impl_primary_expression_test.cc b/src/reader/wgsl/parser_impl_primary_expression_test.cc
index 80f2940..1be32d7 100644
--- a/src/reader/wgsl/parser_impl_primary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_primary_expression_test.cc
@@ -23,8 +23,6 @@
#include "src/ast/type/f32_type.h"
#include "src/ast/type/i32_type.h"
#include "src/ast/type_constructor_expression.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/reader/wgsl/parser_impl.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
diff --git a/src/reader/wgsl/parser_impl_unary_expression_test.cc b/src/reader/wgsl/parser_impl_unary_expression_test.cc
index a11bc78..fad15fc 100644
--- a/src/reader/wgsl/parser_impl_unary_expression_test.cc
+++ b/src/reader/wgsl/parser_impl_unary_expression_test.cc
@@ -17,8 +17,6 @@
#include "src/ast/identifier_expression.h"
#include "src/ast/int_literal.h"
#include "src/ast/scalar_constructor_expression.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/reader/wgsl/parser_impl.h"
#include "src/reader/wgsl/parser_impl_test_helper.h"
@@ -99,732 +97,6 @@
EXPECT_EQ(p->error(), "1:2: unable to parse right side of ! expression");
}
-TEST_F(ParserImplTest, UnaryExpression_Any) {
- auto* p = parser("any(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kAny);
- ASSERT_EQ(u->params().size(), 1u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Any_MissingParenLeft) {
- auto* p = parser("any a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Any_MissingParenRight) {
- auto* p = parser("any(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Any_MissingIdentifier) {
- auto* p = parser("any()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Any_InvalidIdentifier) {
- auto* p = parser("any(123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_All) {
- auto* p = parser("all(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kAll);
- ASSERT_EQ(u->params().size(), 1u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_All_MissingParenLeft) {
- auto* p = parser("all a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_All_MissingParenRight) {
- auto* p = parser("all(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_All_MissingIdentifier) {
- auto* p = parser("all()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_All_InvalidIdentifier) {
- auto* p = parser("all(123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNan) {
- auto* p = parser("is_nan(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kIsNan);
- ASSERT_EQ(u->params().size(), 1u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNan_MissingParenLeft) {
- auto* p = parser("is_nan a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNan_MissingParenRight) {
- auto* p = parser("is_nan(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:9: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNan_MissingIdentifier) {
- auto* p = parser("is_nan()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNan_InvalidIdentifier) {
- auto* p = parser("is_nan(123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsInf) {
- auto* p = parser("is_inf(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kIsInf);
- ASSERT_EQ(u->params().size(), 1u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsInf_MissingParenLeft) {
- auto* p = parser("is_inf a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsInf_MissingParenRight) {
- auto* p = parser("is_inf(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:9: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsInf_MissingIdentifier) {
- auto* p = parser("is_inf()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsInf_InvalidIdentifier) {
- auto* p = parser("is_inf(123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsFinite) {
- auto* p = parser("is_finite(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kIsFinite);
- ASSERT_EQ(u->params().size(), 1u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsFinite_MissingParenLeft) {
- auto* p = parser("is_finite a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:11: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsFinite_MissingParenRight) {
- auto* p = parser("is_finite(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:12: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsFinite_MissingIdentifier) {
- auto* p = parser("is_finite()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:11: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsFinite_InvalidIdentifier) {
- auto* p = parser("is_finite(123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:11: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNormal) {
- auto* p = parser("is_normal(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kIsNormal);
- ASSERT_EQ(u->params().size(), 1u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNormal_MissingParenLeft) {
- auto* p = parser("is_normal a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:11: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNormal_MissingParenRight) {
- auto* p = parser("is_normal(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:12: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNormal_MissingIdentifier) {
- auto* p = parser("is_normal()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:11: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_IsNormal_InvalidIdentifier) {
- auto* p = parser("is_normal(123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:11: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot) {
- auto* p = parser("dot(a, b)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kDot);
- ASSERT_EQ(u->params().size(), 2u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-
- ASSERT_TRUE(u->params()[1]->IsIdentifier());
- ident = u->params()[1]->AsIdentifier();
- EXPECT_EQ(ident->name(), "b");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot_MissingParenLeft) {
- auto* p = parser("dot a, b)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot_MissingParenRight) {
- auto* p = parser("dot(a, b");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:9: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot_MissingFirstIdentifier) {
- auto* p = parser("dot(, a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot_MissingSecondIdentifier) {
- auto* p = parser("dot(a, )");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot_MissingComma) {
- auto* p = parser("dot(a b)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:7: missing , for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot_InvalidFirstIdentifier) {
- auto* p = parser("dot(123, b)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:5: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dot_InvalidSecondIdentifier) {
- auto* p = parser("dot(a, 123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct) {
- auto* p = parser("outer_product(a, b)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryMethod());
-
- auto* u = e->AsUnaryMethod();
- ASSERT_EQ(u->op(), ast::UnaryMethod::kOuterProduct);
- ASSERT_EQ(u->params().size(), 2u);
- ASSERT_TRUE(u->params()[0]->IsIdentifier());
- auto* ident = u->params()[0]->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-
- ASSERT_TRUE(u->params()[1]->IsIdentifier());
- ident = u->params()[1]->AsIdentifier();
- EXPECT_EQ(ident->name(), "b");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingParenLeft) {
- auto* p = parser("outer_product a, b)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:15: missing ( for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingParenRight) {
- auto* p = parser("outer_product(a, b");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:19: missing ) for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingFirstIdentifier) {
- auto* p = parser("outer_product(, b)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:15: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingSecondIdentifier) {
- auto* p = parser("outer_product(a, )");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:18: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct_MissingComma) {
- auto* p = parser("outer_product(a b)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:17: missing , for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct_InvalidFirstIdentifier) {
- auto* p = parser("outer_product(123, b)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:15: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_OuterProduct_InvalidSecondIdentifier) {
- auto* p = parser("outer_product(a, 123)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:18: missing identifier for method call");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_NoModifier) {
- auto* p = parser("dpdx(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryDerivative());
-
- auto* deriv = e->AsUnaryDerivative();
- EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdx);
- EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kNone);
-
- ASSERT_NE(deriv->param(), nullptr);
- ASSERT_TRUE(deriv->param()->IsIdentifier());
- auto* ident = deriv->param()->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_WithModifier) {
- auto* p = parser("dpdx<coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryDerivative());
-
- auto* deriv = e->AsUnaryDerivative();
- EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdx);
- EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kCoarse);
-
- ASSERT_NE(deriv->param(), nullptr);
- ASSERT_TRUE(deriv->param()->IsIdentifier());
- auto* ident = deriv->param()->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingLessThan) {
- auto* p = parser("dpdx coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_InvalidModifier) {
- auto* p = parser("dpdx<invalid>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: unable to parse derivative modifier");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_EmptyModifer) {
- auto* p = parser("dpdx coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingGreaterThan) {
- auto* p = parser("dpdx<coarse (a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:13: missing > for derivative modifier");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_MisisngLeftParen) {
- auto* p = parser("dpdx<coarse>a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:13: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingRightParen) {
- auto* p = parser("dpdx<coarse>(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:15: missing ) for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_MissingIdentifier) {
- auto* p = parser("dpdx<coarse>()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:14: missing identifier for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdx_InvalidIdentifeir) {
- auto* p = parser("dpdx<coarse>(12345)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:14: missing identifier for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_NoModifier) {
- auto* p = parser("dpdy(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryDerivative());
-
- auto* deriv = e->AsUnaryDerivative();
- EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdy);
- EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kNone);
-
- ASSERT_NE(deriv->param(), nullptr);
- ASSERT_TRUE(deriv->param()->IsIdentifier());
- auto* ident = deriv->param()->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_WithModifier) {
- auto* p = parser("dpdy<fine>(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryDerivative());
-
- auto* deriv = e->AsUnaryDerivative();
- EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kDpdy);
- EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kFine);
-
- ASSERT_NE(deriv->param(), nullptr);
- ASSERT_TRUE(deriv->param()->IsIdentifier());
- auto* ident = deriv->param()->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingLessThan) {
- auto* p = parser("dpdy coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_InvalidModifier) {
- auto* p = parser("dpdy<invalid>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: unable to parse derivative modifier");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_EmptyModifer) {
- auto* p = parser("dpdy coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:6: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingGreaterThan) {
- auto* p = parser("dpdy<coarse (a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:13: missing > for derivative modifier");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_MisisngLeftParen) {
- auto* p = parser("dpdy<coarse>a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:13: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingRightParen) {
- auto* p = parser("dpdy<coarse>(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:15: missing ) for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_MissingIdentifier) {
- auto* p = parser("dpdy<coarse>()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:14: missing identifier for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Dpdy_InvalidIdentifeir) {
- auto* p = parser("dpdy<coarse>(12345)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:14: missing identifier for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_NoModifier) {
- auto* p = parser("fwidth(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryDerivative());
-
- auto* deriv = e->AsUnaryDerivative();
- EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kFwidth);
- EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kNone);
-
- ASSERT_NE(deriv->param(), nullptr);
- ASSERT_TRUE(deriv->param()->IsIdentifier());
- auto* ident = deriv->param()->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_WithModifier) {
- auto* p = parser("fwidth<coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_FALSE(p->has_error()) << p->error();
- ASSERT_NE(e, nullptr);
- ASSERT_TRUE(e->IsUnaryDerivative());
-
- auto* deriv = e->AsUnaryDerivative();
- EXPECT_EQ(deriv->op(), ast::UnaryDerivative::kFwidth);
- EXPECT_EQ(deriv->modifier(), ast::DerivativeModifier::kCoarse);
-
- ASSERT_NE(deriv->param(), nullptr);
- ASSERT_TRUE(deriv->param()->IsIdentifier());
- auto* ident = deriv->param()->AsIdentifier();
- EXPECT_EQ(ident->name(), "a");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingLessThan) {
- auto* p = parser("fwidth coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_InvalidModifier) {
- auto* p = parser("fwidth<invalid>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: unable to parse derivative modifier");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_EmptyModifer) {
- auto* p = parser("fwidth coarse>(a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:8: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingGreaterThan) {
- auto* p = parser("fwidth<coarse (a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:15: missing > for derivative modifier");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_MisisngLeftParen) {
- auto* p = parser("fwidth<coarse>a)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:15: missing ( for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingRightParen) {
- auto* p = parser("fwidth<coarse>(a");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:17: missing ) for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidth_MissingIdentifier) {
- auto* p = parser("fwidth<coarse>()");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:16: missing identifier for derivative method");
-}
-
-TEST_F(ParserImplTest, UnaryExpression_Fwidht_InvalidIdentifeir) {
- auto* p = parser("fwidth<coarse>(12345)");
- auto e = p->unary_expression();
- ASSERT_TRUE(p->has_error());
- ASSERT_EQ(e, nullptr);
- EXPECT_EQ(p->error(), "1:16: missing identifier for derivative method");
-}
-
} // namespace
} // namespace wgsl
} // namespace reader
diff --git a/src/reader/wgsl/parser_impl_variable_decoration_test.cc b/src/reader/wgsl/parser_impl_variable_decoration_test.cc
index 4fc9e5c..dc1a5b0 100644
--- a/src/reader/wgsl/parser_impl_variable_decoration_test.cc
+++ b/src/reader/wgsl/parser_impl_variable_decoration_test.cc
@@ -116,7 +116,6 @@
EXPECT_EQ(p->error(), "1:8: expected identifier for builtin");
}
-
TEST_F(ParserImplTest, VariableDecoration_Builtin_InvalidValue) {
auto* p = parser("builtin other_thingy");
auto deco = p->variable_decoration();
diff --git a/src/reader/wgsl/token.cc b/src/reader/wgsl/token.cc
index 300fbe4..2976a95 100644
--- a/src/reader/wgsl/token.cc
+++ b/src/reader/wgsl/token.cc
@@ -105,10 +105,6 @@
case Token::Type::kXor:
return "^";
- case Token::Type::kAll:
- return "all";
- case Token::Type::kAny:
- return "any";
case Token::Type::kArray:
return "array";
case Token::Type::kAs:
@@ -135,16 +131,8 @@
return "continue";
case Token::Type::kContinuing:
return "continuing";
- case Token::Type::kCoarse:
- return "coarse";
case Token::Type::kDefault:
return "default";
- case Token::Type::kDot:
- return "dot";
- case Token::Type::kDpdx:
- return "dpdx";
- case Token::Type::kDpdy:
- return "dpdy";
case Token::Type::kElse:
return "else";
case Token::Type::kElseIf:
@@ -157,16 +145,12 @@
return "fallthrough";
case Token::Type::kFalse:
return "false";
- case Token::Type::kFine:
- return "fine";
case Token::Type::kFn:
return "fn";
case Token::Type::kFragment:
return "fragment";
case Token::Type::kFunction:
return "function";
- case Token::Type::kFwidth:
- return "fwidth";
case Token::Type::kI32:
return "i32";
case Token::Type::kIf:
@@ -177,14 +161,6 @@
return "import";
case Token::Type::kIn:
return "in";
- case Token::Type::kIsNan:
- return "is_nan";
- case Token::Type::kIsInf:
- return "is_inf";
- case Token::Type::kIsFinite:
- return "is_finite";
- case Token::Type::kIsNormal:
- return "is_normal";
case Token::Type::kKill:
return "kill";
case Token::Type::kLocation:
@@ -213,8 +189,6 @@
return "offset";
case Token::Type::kOut:
return "out";
- case Token::Type::kOuterProduct:
- return "outer_product";
case Token::Type::kPremerge:
return "premerge";
case Token::Type::kPrivate:
diff --git a/src/reader/wgsl/token.h b/src/reader/wgsl/token.h
index 53a37cd..f5a2c5f 100644
--- a/src/reader/wgsl/token.h
+++ b/src/reader/wgsl/token.h
@@ -116,10 +116,6 @@
/// A '^'
kXor,
- /// A 'all'
- kAll,
- /// A 'any'
- kAny,
/// A 'array'
kArray,
/// A 'as'
@@ -146,16 +142,8 @@
kContinue,
/// A 'continuing'
kContinuing,
- /// A 'coarse'
- kCoarse,
/// A 'default'
kDefault,
- /// A 'dot'
- kDot,
- /// A 'dpdx'
- kDpdx,
- /// A 'dpdy'
- kDpdy,
/// A 'else'
kElse,
/// A 'elseif'
@@ -168,16 +156,12 @@
kFallthrough,
/// A 'false'
kFalse,
- /// A 'fine'
- kFine,
/// A 'fn'
kFn,
/// A 'fragment'
kFragment,
/// A 'function'
kFunction,
- /// A 'fwidth'
- kFwidth,
/// A 'i32'
kI32,
/// A 'if'
@@ -188,14 +172,6 @@
kImport,
/// A 'in'
kIn,
- /// A 'is_nan'
- kIsNan,
- /// A 'is_inf'
- kIsInf,
- /// A 'is_finite'
- kIsFinite,
- /// A 'is_normal'
- kIsNormal,
/// A 'kill'
kKill,
/// A 'location'
@@ -224,8 +200,6 @@
kOffset,
/// A 'out'
kOut,
- /// A 'outer_product'
- kOuterProduct,
/// A 'premerge'
kPremerge,
/// A 'private'
@@ -401,10 +375,6 @@
/// @returns true if token is a '^'
bool IsXor() const { return type_ == Type::kXor; }
- /// @returns true if token is a 'all'
- bool IsAll() const { return type_ == Type::kAll; }
- /// @returns true if token is a 'any'
- bool IsAny() const { return type_ == Type::kAny; }
/// @returns true if token is a 'array'
bool IsArray() const { return type_ == Type::kArray; }
/// @returns true if token is a 'as'
@@ -423,8 +393,6 @@
bool IsCase() const { return type_ == Type::kCase; }
/// @returns true if token is a 'cast'
bool IsCast() const { return type_ == Type::kCast; }
- /// @returns true if token is 'coarse'
- bool IsCoarse() const { return type_ == Type::kCoarse; }
/// @returns true if token is a 'compute'
bool IsCompute() const { return type_ == Type::kCompute; }
/// @returns true if token is a 'const'
@@ -435,12 +403,6 @@
bool IsContinuing() const { return type_ == Type::kContinuing; }
/// @returns true if token is a 'default'
bool IsDefault() const { return type_ == Type::kDefault; }
- /// @returns true if token is a 'dot'
- bool IsDot() const { return type_ == Type::kDot; }
- /// @returns true if token is a 'dpdx'
- bool IsDpdx() const { return type_ == Type::kDpdx; }
- /// @returns true if token is a 'dpdy'
- bool IsDpdy() const { return type_ == Type::kDpdy; }
/// @returns true if token is a 'else'
bool IsElse() const { return type_ == Type::kElse; }
/// @returns true if token is a 'elseif'
@@ -453,16 +415,12 @@
bool IsFallthrough() const { return type_ == Type::kFallthrough; }
/// @returns true if token is a 'false'
bool IsFalse() const { return type_ == Type::kFalse; }
- /// @returns true if token is a 'fine'
- bool IsFine() const { return type_ == Type::kFine; }
/// @returns true if token is a 'fn'
bool IsFn() const { return type_ == Type::kFn; }
/// @returns true if token is a 'fragment'
bool IsFragment() const { return type_ == Type::kFragment; }
/// @returns true if token is a 'function'
bool IsFunction() const { return type_ == Type::kFunction; }
- /// @returns true if token is a 'fwidth'
- bool IsFwidth() const { return type_ == Type::kFwidth; }
/// @returns true if token is a 'i32'
bool IsI32() const { return type_ == Type::kI32; }
/// @returns true if token is a 'if'
@@ -473,14 +431,6 @@
bool IsImport() const { return type_ == Type::kImport; }
/// @returns true if token is a 'in'
bool IsIn() const { return type_ == Type::kIn; }
- /// @returns true if token is a 'is_nan'
- bool IsIsNan() const { return type_ == Type::kIsNan; }
- /// @returns true if token is a 'is_inf'
- bool IsIsInf() const { return type_ == Type::kIsInf; }
- /// @returns true if token is a 'is_finite'
- bool IsIsFinite() const { return type_ == Type::kIsFinite; }
- /// @returns true if token is a 'is_normal'
- bool IsIsNormal() const { return type_ == Type::kIsNormal; }
/// @returns true if token is a 'kill'
bool IsKill() const { return type_ == Type::kKill; }
/// @returns true if token is a 'location'
@@ -509,8 +459,6 @@
bool IsOffset() const { return type_ == Type::kOffset; }
/// @returns true if token is a 'out'
bool IsOut() const { return type_ == Type::kOut; }
- /// @returns true if token is a 'outer_product'
- bool IsOuterProduct() const { return type_ == Type::kOuterProduct; }
/// @returns true if token is a 'private'
bool IsPrivate() const { return type_ == Type::kPrivate; }
/// @returns true if token is a 'ptr'
diff --git a/src/type_determiner.cc b/src/type_determiner.cc
index 0def870..beddba4 100644
--- a/src/type_determiner.cc
+++ b/src/type_determiner.cc
@@ -42,13 +42,30 @@
#include "src/ast/type/struct_type.h"
#include "src/ast/type/vector_type.h"
#include "src/ast/type_constructor_expression.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/ast/unless_statement.h"
#include "src/ast/variable_decl_statement.h"
namespace tint {
+namespace {
+
+bool IsDerivative(const std::string& name) {
+ return name == "dpdx" || name == "dpdx_fine" || name == "dpdx_coarse" ||
+ name == "dpdy" || name == "dpdy_fine" || name == "dpdy_coarse" ||
+ name == "fwidth" || name == "fwidth_fine" || name == "fwidth_coarse";
+}
+
+bool IsFloatIntrinsic(const std::string& name) {
+ return name == "is_finite" || name == "is_inf" || name == "is_nan" ||
+ name == "is_normal";
+}
+
+bool IsIntrinsic(const std::string& name) {
+ return IsDerivative(name) || name == "all" || name == "any" ||
+ IsFloatIntrinsic(name) || name == "dot" || name == "outer_product";
+}
+
+} // namespace
TypeDeterminer::TypeDeterminer(Context* ctx, ast::Module* mod)
: ctx_(*ctx), mod_(mod) {}
@@ -253,12 +270,6 @@
if (expr->IsMemberAccessor()) {
return DetermineMemberAccessor(expr->AsMemberAccessor());
}
- if (expr->IsUnaryDerivative()) {
- return DetermineUnaryDerivative(expr->AsUnaryDerivative());
- }
- if (expr->IsUnaryMethod()) {
- return DetermineUnaryMethod(expr->AsUnaryMethod());
- }
if (expr->IsUnaryOp()) {
return DetermineUnaryOp(expr->AsUnaryOp());
}
@@ -318,7 +329,11 @@
if (expr->func()->IsIdentifier()) {
auto* ident = expr->func()->AsIdentifier();
- if (ident->has_path()) {
+ if (IsIntrinsic(ident->name())) {
+ if (!DetermineIntrinsic(ident->name(), expr))
+ return false;
+
+ } else if (ident->has_path()) {
auto* imp = mod_->FindImportByName(ident->path());
if (imp == nullptr) {
set_error(expr->source(), "Unable to find import for " + ident->name());
@@ -355,6 +370,75 @@
return true;
}
+bool TypeDeterminer::DetermineIntrinsic(const std::string& name,
+ ast::CallExpression* expr) {
+ if (IsDerivative(name)) {
+ if (expr->params().size() != 1) {
+ set_error(expr->source(), "incorrect number of parameters for " + name);
+ return false;
+ }
+
+ // The result type must be the same as the type of the parameter.
+ auto& param = expr->params()[0];
+ if (!DetermineResultType(param.get())) {
+ return false;
+ }
+ expr->func()->set_result_type(param->result_type()->UnwrapPtrIfNeeded());
+ return true;
+ }
+ if (name == "any" || name == "all") {
+ expr->func()->set_result_type(
+ ctx_.type_mgr().Get(std::make_unique<ast::type::BoolType>()));
+ return true;
+ }
+ if (IsFloatIntrinsic(name)) {
+ if (expr->params().size() != 1) {
+ set_error(expr->source(), "incorrect number of parameters for " + name);
+ return false;
+ }
+
+ auto* bool_type =
+ ctx_.type_mgr().Get(std::make_unique<ast::type::BoolType>());
+
+ auto* param_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
+ if (param_type->IsVector()) {
+ expr->func()->set_result_type(
+ ctx_.type_mgr().Get(std::make_unique<ast::type::VectorType>(
+ bool_type, param_type->AsVector()->size())));
+ } else {
+ expr->func()->set_result_type(bool_type);
+ }
+ return true;
+ }
+ if (name == "dot") {
+ expr->func()->set_result_type(
+ ctx_.type_mgr().Get(std::make_unique<ast::type::F32Type>()));
+ return true;
+ }
+ if (name == "outer_product") {
+ if (expr->params().size() != 2) {
+ set_error(expr->source(),
+ "incorrect number of parameters for outer_product");
+ return false;
+ }
+
+ auto* param0_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
+ auto* param1_type = expr->params()[1]->result_type()->UnwrapPtrIfNeeded();
+ if (!param0_type->IsVector() || !param1_type->IsVector()) {
+ set_error(expr->source(), "invalid parameter type for outer_product");
+ return false;
+ }
+
+ expr->func()->set_result_type(
+ ctx_.type_mgr().Get(std::make_unique<ast::type::MatrixType>(
+ ctx_.type_mgr().Get(std::make_unique<ast::type::F32Type>()),
+ param0_type->AsVector()->size(), param1_type->AsVector()->size())));
+ return true;
+ }
+
+ return false;
+}
+
bool TypeDeterminer::DetermineCast(ast::CastExpression* expr) {
if (!DetermineResultType(expr->expr())) {
return false;
@@ -550,77 +634,6 @@
return false;
}
-bool TypeDeterminer::DetermineUnaryDerivative(
- ast::UnaryDerivativeExpression* expr) {
- // The result type must be the same as the type of the parameter.
- if (!DetermineResultType(expr->param())) {
- return false;
- }
- expr->set_result_type(expr->param()->result_type()->UnwrapPtrIfNeeded());
- return true;
-}
-
-bool TypeDeterminer::DetermineUnaryMethod(ast::UnaryMethodExpression* expr) {
- if (!DetermineResultType(expr->params())) {
- return false;
- }
-
- switch (expr->op()) {
- case ast::UnaryMethod::kAny:
- case ast::UnaryMethod::kAll: {
- expr->set_result_type(
- ctx_.type_mgr().Get(std::make_unique<ast::type::BoolType>()));
- break;
- }
- case ast::UnaryMethod::kIsNan:
- case ast::UnaryMethod::kIsInf:
- case ast::UnaryMethod::kIsFinite:
- case ast::UnaryMethod::kIsNormal: {
- if (expr->params().empty()) {
- set_error(expr->source(), "incorrect number of parameters");
- return false;
- }
-
- auto* bool_type =
- ctx_.type_mgr().Get(std::make_unique<ast::type::BoolType>());
- auto* param_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
- if (param_type->IsVector()) {
- expr->set_result_type(
- ctx_.type_mgr().Get(std::make_unique<ast::type::VectorType>(
- bool_type, param_type->AsVector()->size())));
- } else {
- expr->set_result_type(bool_type);
- }
- break;
- }
- case ast::UnaryMethod::kDot: {
- expr->set_result_type(
- ctx_.type_mgr().Get(std::make_unique<ast::type::F32Type>()));
- break;
- }
- case ast::UnaryMethod::kOuterProduct: {
- if (expr->params().size() != 2) {
- set_error(expr->source(),
- "incorrect number of parameters for outer product");
- return false;
- }
- auto* param0_type = expr->params()[0]->result_type()->UnwrapPtrIfNeeded();
- auto* param1_type = expr->params()[1]->result_type()->UnwrapPtrIfNeeded();
- if (!param0_type->IsVector() || !param1_type->IsVector()) {
- set_error(expr->source(), "invalid parameter type for outer product");
- return false;
- }
- expr->set_result_type(
- ctx_.type_mgr().Get(std::make_unique<ast::type::MatrixType>(
- ctx_.type_mgr().Get(std::make_unique<ast::type::F32Type>()),
- param0_type->AsVector()->size(),
- param1_type->AsVector()->size())));
- break;
- }
- }
- return true;
-}
-
bool TypeDeterminer::DetermineUnaryOp(ast::UnaryOpExpression* expr) {
// Result type matches the parameter type.
if (!DetermineResultType(expr->expr())) {
diff --git a/src/type_determiner.h b/src/type_determiner.h
index 770e00b..7f62a57 100644
--- a/src/type_determiner.h
+++ b/src/type_determiner.h
@@ -34,8 +34,6 @@
class Function;
class IdentifierExpression;
class MemberAccessorExpression;
-class UnaryDerivativeExpression;
-class UnaryMethodExpression;
class UnaryOpExpression;
class Variable;
@@ -114,9 +112,8 @@
bool DetermineCast(ast::CastExpression* expr);
bool DetermineConstructor(ast::ConstructorExpression* expr);
bool DetermineIdentifier(ast::IdentifierExpression* expr);
+ bool DetermineIntrinsic(const std::string& name, ast::CallExpression* expr);
bool DetermineMemberAccessor(ast::MemberAccessorExpression* expr);
- bool DetermineUnaryDerivative(ast::UnaryDerivativeExpression* expr);
- bool DetermineUnaryMethod(ast::UnaryMethodExpression* expr);
bool DetermineUnaryOp(ast::UnaryOpExpression* expr);
Context& ctx_;
diff --git a/src/type_determiner_test.cc b/src/type_determiner_test.cc
index bb44112..5104709 100644
--- a/src/type_determiner_test.cc
+++ b/src/type_determiner_test.cc
@@ -51,8 +51,6 @@
#include "src/ast/type/struct_type.h"
#include "src/ast/type/vector_type.h"
#include "src/ast/type_constructor_expression.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/ast/unless_statement.h"
#include "src/ast/variable_decl_statement.h"
@@ -1369,13 +1367,34 @@
EXPECT_EQ(mat->columns(), 4u);
}
-using UnaryDerivativeExpressionTest =
- TypeDeterminerTestWithParam<ast::UnaryDerivative>;
-TEST_P(UnaryDerivativeExpressionTest, Expr_UnaryDerivative) {
- auto derivative = GetParam();
+using IntrinsicDerivativeTest = TypeDeterminerTestWithParam<std::string>;
+TEST_P(IntrinsicDerivativeTest, Scalar) {
+ auto name = GetParam();
ast::type::F32Type f32;
+ auto var =
+ std::make_unique<ast::Variable>("ident", ast::StorageClass::kNone, &f32);
+ mod()->AddGlobalVariable(std::move(var));
+
+ // Register the global
+ EXPECT_TRUE(td()->Determine());
+
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("ident"));
+
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
+ EXPECT_TRUE(td()->DetermineResultType(&expr));
+
+ ASSERT_NE(expr.result_type(), nullptr);
+ ASSERT_TRUE(expr.result_type()->IsF32());
+}
+
+TEST_P(IntrinsicDerivativeTest, Vector) {
+ auto name = GetParam();
+
+ ast::type::F32Type f32;
ast::type::VectorType vec4(&f32, 4);
auto var =
@@ -1385,25 +1404,75 @@
// Register the global
EXPECT_TRUE(td()->Determine());
- ast::UnaryDerivativeExpression der(
- derivative, ast::DerivativeModifier::kNone,
- std::make_unique<ast::IdentifierExpression>("ident"));
- EXPECT_TRUE(td()->DetermineResultType(&der));
- ASSERT_NE(der.result_type(), nullptr);
- ASSERT_TRUE(der.result_type()->IsVector());
- EXPECT_TRUE(der.result_type()->AsVector()->type()->IsF32());
- EXPECT_EQ(der.result_type()->AsVector()->size(), 4u);
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("ident"));
+
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
+ EXPECT_TRUE(td()->DetermineResultType(&expr));
+
+ ASSERT_NE(expr.result_type(), nullptr);
+ ASSERT_TRUE(expr.result_type()->IsVector());
+ EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsF32());
+ EXPECT_EQ(expr.result_type()->AsVector()->size(), 4u);
+}
+
+TEST_P(IntrinsicDerivativeTest, MissingParam) {
+ auto name = GetParam();
+
+ ast::type::F32Type f32;
+ ast::type::VectorType vec4(&f32, 4);
+
+ // Register the global
+ EXPECT_TRUE(td()->Determine());
+
+ ast::ExpressionList call_params;
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
+ EXPECT_FALSE(td()->DetermineResultType(&expr));
+ EXPECT_EQ(td()->error(), "incorrect number of parameters for " + name);
+}
+
+TEST_P(IntrinsicDerivativeTest, ToomManyParams) {
+ auto name = GetParam();
+
+ ast::type::F32Type f32;
+ ast::type::VectorType vec4(&f32, 4);
+
+ auto var1 = std::make_unique<ast::Variable>("ident1",
+ ast::StorageClass::kNone, &vec4);
+ auto var2 = std::make_unique<ast::Variable>("ident2",
+ ast::StorageClass::kNone, &vec4);
+ mod()->AddGlobalVariable(std::move(var1));
+ mod()->AddGlobalVariable(std::move(var2));
+
+ // Register the global
+ EXPECT_TRUE(td()->Determine());
+
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("ident1"));
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("ident2"));
+
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
+ EXPECT_FALSE(td()->DetermineResultType(&expr));
+ EXPECT_EQ(td()->error(), "incorrect number of parameters for " + name);
}
INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
- UnaryDerivativeExpressionTest,
- testing::Values(ast::UnaryDerivative::kDpdx,
- ast::UnaryDerivative::kDpdy,
- ast::UnaryDerivative::kFwidth));
+ IntrinsicDerivativeTest,
+ testing::Values("dpdx",
+ "dpdx_coarse",
+ "dpdx_fine",
+ "dpdy",
+ "dpdy_coarse",
+ "dpdy_fine",
+ "fwidth",
+ "fwidth_coarse",
+ "fwidth_fine"));
-using UnaryMethodExpressionBoolTest =
- TypeDeterminerTestWithParam<ast::UnaryMethod>;
-TEST_P(UnaryMethodExpressionBoolTest, Expr_UnaryMethod_Any) {
- auto op = GetParam();
+using Intrinsic = TypeDeterminerTestWithParam<std::string>;
+TEST_P(Intrinsic, Test) {
+ auto name = GetParam();
ast::type::BoolType bool_type;
ast::type::VectorType vec3(&bool_type, 3);
@@ -1412,27 +1481,26 @@
&vec3);
mod()->AddGlobalVariable(std::move(var));
- ast::ExpressionList params;
- params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
- ast::UnaryMethodExpression exp(op, std::move(params));
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
// Register the variable
EXPECT_TRUE(td()->Determine());
- EXPECT_TRUE(td()->DetermineResultType(&exp));
- ASSERT_NE(exp.result_type(), nullptr);
- EXPECT_TRUE(exp.result_type()->IsBool());
+ EXPECT_TRUE(td()->DetermineResultType(&expr));
+ ASSERT_NE(expr.result_type(), nullptr);
+ EXPECT_TRUE(expr.result_type()->IsBool());
}
INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
- UnaryMethodExpressionBoolTest,
- testing::Values(ast::UnaryMethod::kAny,
- ast::UnaryMethod::kAll));
+ Intrinsic,
+ testing::Values("any", "all"));
-using UnaryMethodExpressionVecTest =
- TypeDeterminerTestWithParam<ast::UnaryMethod>;
-TEST_P(UnaryMethodExpressionVecTest, Expr_UnaryMethod_Bool) {
- auto op = GetParam();
+using Intrinsic_FloatMethod = TypeDeterminerTestWithParam<std::string>;
+TEST_P(Intrinsic_FloatMethod, Vector) {
+ auto name = GetParam();
ast::type::F32Type f32;
ast::type::VectorType vec3(&f32, 3);
@@ -1441,22 +1509,24 @@
&vec3);
mod()->AddGlobalVariable(std::move(var));
- ast::ExpressionList params;
- params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
- ast::UnaryMethodExpression exp(op, std::move(params));
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
// Register the variable
EXPECT_TRUE(td()->Determine());
+ EXPECT_TRUE(td()->DetermineResultType(&expr));
- EXPECT_TRUE(td()->DetermineResultType(&exp));
- ASSERT_NE(exp.result_type(), nullptr);
- ASSERT_TRUE(exp.result_type()->IsVector());
- EXPECT_TRUE(exp.result_type()->AsVector()->type()->IsBool());
- EXPECT_EQ(exp.result_type()->AsVector()->size(), 3u);
+ ASSERT_NE(expr.result_type(), nullptr);
+ ASSERT_TRUE(expr.result_type()->IsVector());
+ EXPECT_TRUE(expr.result_type()->AsVector()->type()->IsBool());
+ EXPECT_EQ(expr.result_type()->AsVector()->size(), 3u);
}
-TEST_P(UnaryMethodExpressionVecTest, Expr_UnaryMethod_Vec) {
- auto op = GetParam();
+
+TEST_P(Intrinsic_FloatMethod, Scalar) {
+ auto name = GetParam();
ast::type::F32Type f32;
@@ -1464,26 +1534,65 @@
std::make_unique<ast::Variable>("my_var", ast::StorageClass::kNone, &f32);
mod()->AddGlobalVariable(std::move(var));
- ast::ExpressionList params;
- params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
- ast::UnaryMethodExpression exp(op, std::move(params));
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
// Register the variable
EXPECT_TRUE(td()->Determine());
-
- EXPECT_TRUE(td()->DetermineResultType(&exp));
- ASSERT_NE(exp.result_type(), nullptr);
- EXPECT_TRUE(exp.result_type()->IsBool());
+ EXPECT_TRUE(td()->DetermineResultType(&expr));
+ ASSERT_NE(expr.result_type(), nullptr);
+ EXPECT_TRUE(expr.result_type()->IsBool());
}
-INSTANTIATE_TEST_SUITE_P(TypeDeterminerTest,
- UnaryMethodExpressionVecTest,
- testing::Values(ast::UnaryMethod::kIsInf,
- ast::UnaryMethod::kIsNan,
- ast::UnaryMethod::kIsFinite,
- ast::UnaryMethod::kIsNormal));
-TEST_F(TypeDeterminerTest, Expr_UnaryMethod_Dot) {
+TEST_P(Intrinsic_FloatMethod, MissingParam) {
+ auto name = GetParam();
+
+ ast::type::F32Type f32;
+
+ auto var =
+ std::make_unique<ast::Variable>("my_var", ast::StorageClass::kNone, &f32);
+ mod()->AddGlobalVariable(std::move(var));
+
+ ast::ExpressionList call_params;
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
+
+ // Register the variable
+ EXPECT_TRUE(td()->Determine());
+ EXPECT_FALSE(td()->DetermineResultType(&expr));
+ EXPECT_EQ(td()->error(), "incorrect number of parameters for " + name);
+}
+
+TEST_P(Intrinsic_FloatMethod, TooManyParams) {
+ auto name = GetParam();
+
+ ast::type::F32Type f32;
+
+ auto var =
+ std::make_unique<ast::Variable>("my_var", ast::StorageClass::kNone, &f32);
+ mod()->AddGlobalVariable(std::move(var));
+
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
+
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>(name),
+ std::move(call_params));
+
+ // Register the variable
+ EXPECT_TRUE(td()->Determine());
+ EXPECT_FALSE(td()->DetermineResultType(&expr));
+ EXPECT_EQ(td()->error(), "incorrect number of parameters for " + name);
+}
+INSTANTIATE_TEST_SUITE_P(
+ TypeDeterminerTest,
+ Intrinsic_FloatMethod,
+ testing::Values("is_inf", "is_nan", "is_finite", "is_normal"));
+
+TEST_F(TypeDeterminerTest, Intrinsic_Dot) {
ast::type::F32Type f32;
ast::type::VectorType vec3(&f32, 3);
@@ -1491,21 +1600,21 @@
&vec3);
mod()->AddGlobalVariable(std::move(var));
- ast::ExpressionList params;
- params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
- params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("my_var"));
- ast::UnaryMethodExpression exp(ast::UnaryMethod::kDot, std::move(params));
+ ast::CallExpression expr(std::make_unique<ast::IdentifierExpression>("dot"),
+ std::move(call_params));
// Register the variable
EXPECT_TRUE(td()->Determine());
-
- EXPECT_TRUE(td()->DetermineResultType(&exp));
- ASSERT_NE(exp.result_type(), nullptr);
- EXPECT_TRUE(exp.result_type()->IsF32());
+ EXPECT_TRUE(td()->DetermineResultType(&expr));
+ ASSERT_NE(expr.result_type(), nullptr);
+ EXPECT_TRUE(expr.result_type()->IsF32());
}
-TEST_F(TypeDeterminerTest, Expr_UnaryMethod_OuterProduct) {
+TEST_F(TypeDeterminerTest, Intrinsic_OuterProduct) {
ast::type::F32Type f32;
ast::type::VectorType vec3(&f32, 3);
ast::type::VectorType vec2(&f32, 2);
@@ -1517,25 +1626,73 @@
mod()->AddGlobalVariable(std::move(var1));
mod()->AddGlobalVariable(std::move(var2));
- ast::ExpressionList params;
- params.push_back(std::make_unique<ast::IdentifierExpression>("v3"));
- params.push_back(std::make_unique<ast::IdentifierExpression>("v2"));
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("v3"));
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("v2"));
- ast::UnaryMethodExpression exp(ast::UnaryMethod::kOuterProduct,
- std::move(params));
+ ast::CallExpression expr(
+ std::make_unique<ast::IdentifierExpression>("outer_product"),
+ std::move(call_params));
// Register the variable
EXPECT_TRUE(td()->Determine());
+ EXPECT_TRUE(td()->DetermineResultType(&expr));
- EXPECT_TRUE(td()->DetermineResultType(&exp));
- ASSERT_NE(exp.result_type(), nullptr);
- ASSERT_TRUE(exp.result_type()->IsMatrix());
- auto* mat = exp.result_type()->AsMatrix();
+ ASSERT_NE(expr.result_type(), nullptr);
+ ASSERT_TRUE(expr.result_type()->IsMatrix());
+
+ auto* mat = expr.result_type()->AsMatrix();
EXPECT_TRUE(mat->type()->IsF32());
EXPECT_EQ(mat->rows(), 3u);
EXPECT_EQ(mat->columns(), 2u);
}
+TEST_F(TypeDeterminerTest, Intrinsic_OuterProduct_TooFewParams) {
+ ast::type::F32Type f32;
+ ast::type::VectorType vec3(&f32, 3);
+ ast::type::VectorType vec2(&f32, 2);
+
+ auto var2 =
+ std::make_unique<ast::Variable>("v2", ast::StorageClass::kNone, &vec2);
+ mod()->AddGlobalVariable(std::move(var2));
+
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("v2"));
+
+ ast::CallExpression expr(
+ std::make_unique<ast::IdentifierExpression>("outer_product"),
+ std::move(call_params));
+
+ // Register the variable
+ EXPECT_TRUE(td()->Determine());
+ EXPECT_FALSE(td()->DetermineResultType(&expr));
+ EXPECT_EQ(td()->error(), "incorrect number of parameters for outer_product");
+}
+
+TEST_F(TypeDeterminerTest, Intrinsic_OuterProduct_TooManyParams) {
+ ast::type::F32Type f32;
+ ast::type::VectorType vec3(&f32, 3);
+ ast::type::VectorType vec2(&f32, 2);
+
+ auto var2 =
+ std::make_unique<ast::Variable>("v2", ast::StorageClass::kNone, &vec2);
+ mod()->AddGlobalVariable(std::move(var2));
+
+ ast::ExpressionList call_params;
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("v2"));
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("v2"));
+ call_params.push_back(std::make_unique<ast::IdentifierExpression>("v2"));
+
+ ast::CallExpression expr(
+ std::make_unique<ast::IdentifierExpression>("outer_product"),
+ std::move(call_params));
+
+ // Register the variable
+ EXPECT_TRUE(td()->Determine());
+ EXPECT_FALSE(td()->DetermineResultType(&expr));
+ EXPECT_EQ(td()->error(), "incorrect number of parameters for outer_product");
+}
+
using UnaryOpExpressionTest = TypeDeterminerTestWithParam<ast::UnaryOp>;
TEST_P(UnaryOpExpressionTest, Expr_UnaryOp) {
auto op = GetParam();
diff --git a/src/writer/wgsl/generator_impl.cc b/src/writer/wgsl/generator_impl.cc
index e3ddceb..c83759e 100644
--- a/src/writer/wgsl/generator_impl.cc
+++ b/src/writer/wgsl/generator_impl.cc
@@ -54,8 +54,6 @@
#include "src/ast/type/vector_type.h"
#include "src/ast/type_constructor_expression.h"
#include "src/ast/uint_literal.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/ast/unary_method_expression.h"
#include "src/ast/unary_op_expression.h"
#include "src/ast/unless_statement.h"
#include "src/ast/variable_decl_statement.h"
@@ -166,12 +164,6 @@
if (expr->IsMemberAccessor()) {
return EmitMemberAccessor(expr->AsMemberAccessor());
}
- if (expr->IsUnaryDerivative()) {
- return EmitUnaryDerivative(expr->AsUnaryDerivative());
- }
- if (expr->IsUnaryMethod()) {
- return EmitUnaryMethod(expr->AsUnaryMethod());
- }
if (expr->IsUnaryOp()) {
return EmitUnaryOp(expr->AsUnaryOp());
}
@@ -595,78 +587,6 @@
return true;
}
-bool GeneratorImpl::EmitUnaryDerivative(ast::UnaryDerivativeExpression* expr) {
- switch (expr->op()) {
- case ast::UnaryDerivative::kDpdx:
- out_ << "dpdx";
- break;
- case ast::UnaryDerivative::kDpdy:
- out_ << "dpdy";
- break;
- case ast::UnaryDerivative::kFwidth:
- out_ << "fwidth";
- break;
- }
-
- if (expr->modifier() != ast::DerivativeModifier::kNone) {
- out_ << "<" << expr->modifier() << ">";
- }
-
- out_ << "(";
-
- if (!EmitExpression(expr->param())) {
- return false;
- }
-
- out_ << ")";
- return true;
-}
-
-bool GeneratorImpl::EmitUnaryMethod(ast::UnaryMethodExpression* expr) {
- switch (expr->op()) {
- case ast::UnaryMethod::kAny:
- out_ << "any";
- break;
- case ast::UnaryMethod::kAll:
- out_ << "all";
- break;
- case ast::UnaryMethod::kIsNan:
- out_ << "is_nan";
- break;
- case ast::UnaryMethod::kIsInf:
- out_ << "is_inf";
- break;
- case ast::UnaryMethod::kIsFinite:
- out_ << "is_finite";
- break;
- case ast::UnaryMethod::kIsNormal:
- out_ << "is_normal";
- break;
- case ast::UnaryMethod::kDot:
- out_ << "dot";
- break;
- case ast::UnaryMethod::kOuterProduct:
- out_ << "outer_product";
- break;
- }
- out_ << "(";
-
- bool first = true;
- for (const auto& param : expr->params()) {
- if (!first) {
- out_ << ", ";
- }
- first = false;
-
- if (!EmitExpression(param.get())) {
- return false;
- }
- }
- out_ << ")";
-
- return true;
-}
-
bool GeneratorImpl::EmitUnaryOp(ast::UnaryOpExpression* expr) {
switch (expr->op()) {
case ast::UnaryOp::kNot:
diff --git a/src/writer/wgsl/generator_impl.h b/src/writer/wgsl/generator_impl.h
index d9282bd..b262a6d 100644
--- a/src/writer/wgsl/generator_impl.h
+++ b/src/writer/wgsl/generator_impl.h
@@ -190,14 +190,6 @@
/// @param expr the type constructor expression
/// @returns true if the constructor is emitted
bool EmitTypeConstructor(ast::TypeConstructorExpression* expr);
- /// Handles a unary derivative expression
- /// @param expr the expression to emit
- /// @returns true if the expression was emitted
- bool EmitUnaryDerivative(ast::UnaryDerivativeExpression* expr);
- /// Handles a unary method expression
- /// @param expr the expression to emit
- /// @returns true if the expression was emitted
- bool EmitUnaryMethod(ast::UnaryMethodExpression* expr);
/// Handles a unary op expression
/// @param expr the expression to emit
/// @returns true if the expression was emitted
diff --git a/src/writer/wgsl/generator_impl_unary_derivative_test.cc b/src/writer/wgsl/generator_impl_unary_derivative_test.cc
deleted file mode 100644
index b7af8dc..0000000
--- a/src/writer/wgsl/generator_impl_unary_derivative_test.cc
+++ /dev/null
@@ -1,83 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-
-#include "gtest/gtest.h"
-#include "src/ast/identifier_expression.h"
-#include "src/ast/unary_derivative_expression.h"
-#include "src/writer/wgsl/generator_impl.h"
-
-namespace tint {
-namespace writer {
-namespace wgsl {
-namespace {
-
-struct UnaryDerivativeData {
- const char* name;
- ast::UnaryDerivative derivative;
-};
-inline std::ostream& operator<<(std::ostream& out, UnaryDerivativeData data) {
- out << data.derivative;
- return out;
-}
-using UnaryDerivativeTest = testing::TestWithParam<UnaryDerivativeData>;
-TEST_P(UnaryDerivativeTest, Emit_ModifierNone) {
- auto params = GetParam();
-
- auto expr = std::make_unique<ast::IdentifierExpression>("expr");
-
- ast::UnaryDerivativeExpression derivative(
- params.derivative, ast::DerivativeModifier::kNone, std::move(expr));
-
- GeneratorImpl g;
- ASSERT_TRUE(g.EmitExpression(&derivative)) << g.error();
- EXPECT_EQ(g.result(), std::string(params.name) + "(expr)");
-}
-TEST_P(UnaryDerivativeTest, Emit_ModifierFine) {
- auto params = GetParam();
-
- auto expr = std::make_unique<ast::IdentifierExpression>("expr");
-
- ast::UnaryDerivativeExpression derivative(
- params.derivative, ast::DerivativeModifier::kFine, std::move(expr));
-
- GeneratorImpl g;
- ASSERT_TRUE(g.EmitExpression(&derivative)) << g.error();
- EXPECT_EQ(g.result(), std::string(params.name) + "<fine>(expr)");
-}
-TEST_P(UnaryDerivativeTest, Emit_ModifierCoarse) {
- auto params = GetParam();
-
- auto expr = std::make_unique<ast::IdentifierExpression>("expr");
-
- ast::UnaryDerivativeExpression derivative(
- params.derivative, ast::DerivativeModifier::kCoarse, std::move(expr));
-
- GeneratorImpl g;
- ASSERT_TRUE(g.EmitExpression(&derivative)) << g.error();
- EXPECT_EQ(g.result(), std::string(params.name) + "<coarse>(expr)");
-}
-INSTANTIATE_TEST_SUITE_P(
- GeneratorImplTest,
- UnaryDerivativeTest,
- testing::Values(UnaryDerivativeData{"dpdx", ast::UnaryDerivative::kDpdx},
- UnaryDerivativeData{"dpdy", ast::UnaryDerivative::kDpdy},
- UnaryDerivativeData{"fwidth",
- ast::UnaryDerivative::kFwidth}));
-
-} // namespace
-} // namespace wgsl
-} // namespace writer
-} // namespace tint
diff --git a/src/writer/wgsl/generator_impl_unary_method_test.cc b/src/writer/wgsl/generator_impl_unary_method_test.cc
deleted file mode 100644
index 83eff87..0000000
--- a/src/writer/wgsl/generator_impl_unary_method_test.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2020 The Tint Authors.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-#include <memory>
-
-#include "gtest/gtest.h"
-#include "src/ast/identifier_expression.h"
-#include "src/ast/unary_method_expression.h"
-#include "src/writer/wgsl/generator_impl.h"
-
-namespace tint {
-namespace writer {
-namespace wgsl {
-namespace {
-
-struct UnaryMethodData {
- const char* name;
- ast::UnaryMethod method;
-};
-inline std::ostream& operator<<(std::ostream& out, UnaryMethodData data) {
- out << data.method;
- return out;
-}
-using UnaryMethodTest = testing::TestWithParam<UnaryMethodData>;
-TEST_P(UnaryMethodTest, Emit) {
- auto params = GetParam();
-
- auto expr = std::make_unique<ast::IdentifierExpression>("expr");
- ast::ExpressionList ops;
- ops.push_back(std::move(expr));
-
- ast::UnaryMethodExpression method(params.method, std::move(ops));
-
- GeneratorImpl g;
- ASSERT_TRUE(g.EmitExpression(&method)) << g.error();
- EXPECT_EQ(g.result(), std::string(params.name) + "(expr)");
-}
-INSTANTIATE_TEST_SUITE_P(
- GeneratorImplTest,
- UnaryMethodTest,
- testing::Values(UnaryMethodData{"any", ast::UnaryMethod::kAny},
- UnaryMethodData{"all", ast::UnaryMethod::kAll},
- UnaryMethodData{"is_nan", ast::UnaryMethod::kIsNan},
- UnaryMethodData{"is_finite", ast::UnaryMethod::kIsFinite},
- UnaryMethodData{"is_normal", ast::UnaryMethod::kIsNormal}));
-
-using UnaryMethodTest_MultiParam = testing::TestWithParam<UnaryMethodData>;
-TEST_P(UnaryMethodTest_MultiParam, Emit) {
- auto params = GetParam();
-
- auto expr1 = std::make_unique<ast::IdentifierExpression>("expr1");
- auto expr2 = std::make_unique<ast::IdentifierExpression>("expr2");
- ast::ExpressionList ops;
- ops.push_back(std::move(expr1));
- ops.push_back(std::move(expr2));
-
- ast::UnaryMethodExpression method(params.method, std::move(ops));
-
- GeneratorImpl g;
- ASSERT_TRUE(g.EmitExpression(&method)) << g.error();
- EXPECT_EQ(g.result(), std::string(params.name) + "(expr1, expr2)");
-}
-INSTANTIATE_TEST_SUITE_P(
- GeneratorImplTest,
- UnaryMethodTest_MultiParam,
- testing::Values(UnaryMethodData{"dot", ast::UnaryMethod::kDot},
- UnaryMethodData{"outer_product",
- ast::UnaryMethod::kOuterProduct}));
-
-} // namespace
-} // namespace wgsl
-} // namespace writer
-} // namespace tint
