mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-07-25 14:35:49 +00:00
8454d824d4
The readers must not produce invalid ASTs. If readers cannot produce a valid AST, then they should error instead. If a reader does produce an invalid AST, this change catches this bad behavior early, significantly helping identify the root of the broken logic. IsValid() made a bit more sense in the days where the AST was mutable, and was constructed by calling setters on the nodes to build up the tree. In order to detect bad ASTs, IsValid() would have to perform an entire AST traversal and give a yes / no answer for the entire tree. Not only was this slow, an answer of 'no' didn't tell you *where* the AST was invalid, resulting in a lot of manual debugging. Now that the AST is fully immutable, all child nodes need to be built before their parents. The AST node constructors now become a perfect place to perform pointer sanity checking. The argument for attempting to catch and handle invalid ASTs is not a compelling one. Invalid ASTs are invalid compiler behavior, not something that should ever happen with a correctly functioning compiler. If this were to happen in production, the user would be utterly clueless to _why_ the program is invalid, or _how_ to fix it. Attempting to handle invalid ASTs is just masking a much larger problem. Let's just let the fuzzers do their job to catch any of these cases early. Fixed: chromium:1185569 Change-Id: I6496426a3a9da9d42627d2c1ca23917bfd04cc5c Reviewed-on: https://dawn-review.googlesource.com/c/tint/+/44048 Commit-Queue: Ben Clayton <bclayton@chromium.org> Reviewed-by: David Neto <dneto@google.com>
66 lines
2.1 KiB
C++
66 lines
2.1 KiB
C++
// 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_ASSIGNMENT_STATEMENT_H_
|
|
#define SRC_AST_ASSIGNMENT_STATEMENT_H_
|
|
|
|
#include "src/ast/expression.h"
|
|
#include "src/ast/statement.h"
|
|
|
|
namespace tint {
|
|
namespace ast {
|
|
|
|
/// An assignment statement
|
|
class AssignmentStatement : public Castable<AssignmentStatement, Statement> {
|
|
public:
|
|
/// Constructor
|
|
/// @param source the assignment statement source
|
|
/// @param lhs the left side of the expression
|
|
/// @param rhs the right side of the expression
|
|
AssignmentStatement(const Source& source, Expression* lhs, Expression* rhs);
|
|
/// Move constructor
|
|
AssignmentStatement(AssignmentStatement&&);
|
|
~AssignmentStatement() override;
|
|
|
|
/// @returns the left side expression
|
|
Expression* lhs() const { return lhs_; }
|
|
/// @returns the right side expression
|
|
Expression* rhs() const { return rhs_; }
|
|
|
|
/// Clones this node and all transitive child nodes using the `CloneContext`
|
|
/// `ctx`.
|
|
/// @param ctx the clone context
|
|
/// @return the newly cloned node
|
|
AssignmentStatement* Clone(CloneContext* ctx) const override;
|
|
|
|
/// Writes a representation of the node to the output stream
|
|
/// @param sem the semantic info for the program
|
|
/// @param out the stream to write to
|
|
/// @param indent number of spaces to indent the node when writing
|
|
void to_str(const semantic::Info& sem,
|
|
std::ostream& out,
|
|
size_t indent) const override;
|
|
|
|
private:
|
|
AssignmentStatement(const AssignmentStatement&) = delete;
|
|
|
|
Expression* const lhs_;
|
|
Expression* const rhs_;
|
|
};
|
|
|
|
} // namespace ast
|
|
} // namespace tint
|
|
|
|
#endif // SRC_AST_ASSIGNMENT_STATEMENT_H_
|