| // 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_CLONE_CONTEXT_H_ | |
| #define SRC_AST_CLONE_CONTEXT_H_ | |
| #include <functional> | |
| #include <unordered_map> | |
| #include <vector> | |
| #include "src/ast/traits.h" | |
| #include "src/castable.h" | |
| #include "src/source.h" | |
| #include "src/symbol.h" | |
| namespace tint { | |
| namespace ast { | |
| class Module; | |
| /// CloneContext holds the state used while cloning AST nodes and types. | |
| class CloneContext { | |
| public: | |
| /// Constructor | |
| /// @param to the target module to clone into | |
| /// @param from the source module to clone from | |
| CloneContext(Module* to, Module const* from); | |
| /// Destructor | |
| ~CloneContext(); | |
| /// Clones the Node or type::Type `a` into the module #mod if `a` is not | |
| /// null. If `a` is null, then Clone() returns null. If `a` has been cloned | |
| /// already by this CloneContext then the same cloned pointer is returned. | |
| /// | |
| /// Clone() may use a function registered with ReplaceAll() to create a | |
| /// transformed version of the object. See ReplaceAll() for more information. | |
| /// | |
| /// The Node or type::Type `a` must be owned by the module #src. | |
| /// | |
| /// @note Semantic information such as resolved expression type and intrinsic | |
| /// information is not cloned. | |
| /// @param a the `Node` or `type::Type` to clone | |
| /// @return the cloned node | |
| template <typename T> | |
| T* Clone(T* a) { | |
| // If the input is nullptr, there's nothing to clone - just return nullptr. | |
| if (a == nullptr) { | |
| return nullptr; | |
| } | |
| // See if we've already cloned this object - if we have return the | |
| // previously cloned pointer. | |
| // If we haven't cloned this before, try cloning using a replacer transform. | |
| if (auto* c = LookupOrTransform(a)) { | |
| return static_cast<T*>(c); | |
| } | |
| // First time clone and no replacer transforms matched. | |
| // Clone with T::Clone(). | |
| auto* c = a->Clone(this); | |
| cloned_.emplace(a, c); | |
| return static_cast<T*>(c); | |
| } | |
| /// Clones the Source `s` into `mod` | |
| /// TODO(bclayton) - Currently this 'clone' is a shallow copy. If/when | |
| /// `Source.File`s are owned by the `Module` this should make a copy of the | |
| /// file. | |
| /// @param s the `Source` to clone | |
| /// @return the cloned source | |
| Source Clone(const Source& s) const { return s; } | |
| /// Clones the Symbol `s` into `mod` | |
| /// | |
| /// The Symbol `s` must be owned by the module #src. | |
| /// | |
| /// @param s the Symbol to clone | |
| /// @return the cloned source | |
| Symbol Clone(const Symbol& s) const; | |
| /// Clones each of the elements of the vector `v` into the module #mod-> | |
| /// | |
| /// All the elements of the vector `v` must be owned by the module #src. | |
| /// | |
| /// @param v the vector to clone | |
| /// @return the cloned vector | |
| template <typename T> | |
| std::vector<T> Clone(const std::vector<T>& v) { | |
| std::vector<T> out; | |
| out.reserve(v.size()); | |
| for (auto& el : v) { | |
| out.emplace_back(Clone(el)); | |
| } | |
| return out; | |
| } | |
| /// ReplaceAll() registers `replacer` to be called whenever the Clone() method | |
| /// is called with a type that matches (or derives from) the type of the | |
| /// second parameter of `replacer`. | |
| /// | |
| /// `replacer` must be function-like with the signature: | |
| /// `T* (CloneContext*, T*)` | |
| /// where `T` is a type deriving from CastableBase. | |
| /// | |
| /// If `replacer` returns a nullptr then Clone() will attempt the next | |
| /// registered replacer function that matches the object type. If no replacers | |
| /// match the object type, or all returned nullptr then Clone() will call | |
| /// `T::Clone()` to clone the object. | |
| /// | |
| /// Example: | |
| /// | |
| /// ``` | |
| /// // Replace all ast::UintLiterals with the number 42 | |
| /// CloneCtx ctx(&out, in) | |
| /// .ReplaceAll([&] (CloneContext* ctx, ast::UintLiteral* l) { | |
| /// return ctx->mod->create<ast::UintLiteral>(ctx->Clone(l->source()), | |
| /// ctx->Clone(l->type()), | |
| /// 42); | |
| /// }).Clone(); | |
| /// ``` | |
| /// | |
| /// @param replacer a function or function-like object with the signature | |
| /// `T* (CloneContext*, T*)`, where `T` derives from CastableBase | |
| /// @returns this CloneContext so calls can be chained | |
| template <typename F> | |
| CloneContext& ReplaceAll(F replacer) { | |
| using TPtr = traits::ParamTypeT<F, 1>; | |
| using T = typename std::remove_pointer<TPtr>::type; | |
| transforms_.emplace_back([=](CastableBase* in) { | |
| auto* in_as_t = in->As<T>(); | |
| return in_as_t != nullptr ? replacer(this, in_as_t) : nullptr; | |
| }); | |
| return *this; | |
| } | |
| /// Clone performs the clone of the entire module #src to #mod. | |
| void Clone(); | |
| /// The target module to clone into. | |
| Module* const mod; | |
| /// The source module to clone from. | |
| Module const* const src; | |
| private: | |
| using Transform = std::function<CastableBase*(CastableBase*)>; | |
| CloneContext(const CloneContext&) = delete; | |
| CloneContext& operator=(const CloneContext&) = delete; | |
| /// LookupOrTransform is the template-independent logic of Clone(). | |
| /// This is outside of Clone() to reduce the amount of template-instantiated | |
| /// code. | |
| CastableBase* LookupOrTransform(CastableBase* a) { | |
| // Have we seen this object before? If so, return the previously cloned | |
| // version instead of making yet another copy. | |
| auto it = cloned_.find(a); | |
| if (it != cloned_.end()) { | |
| return it->second; | |
| } | |
| // Attempt to clone using the registered replacer functions. | |
| for (auto& f : transforms_) { | |
| if (CastableBase* c = f(a)) { | |
| cloned_.emplace(a, c); | |
| return c; | |
| } | |
| } | |
| // No luck, Clone() will have to call T::Clone(). | |
| return nullptr; | |
| } | |
| std::unordered_map<CastableBase*, CastableBase*> cloned_; | |
| std::vector<Transform> transforms_; | |
| }; | |
| } // namespace ast | |
| } // namespace tint | |
| #endif // SRC_AST_CLONE_CONTEXT_H_ |