1  // Copyright (C) 2020-2023 Free Software Foundation, Inc.
       2  
       3  // This file is part of GCC.
       4  
       5  // GCC is free software; you can redistribute it and/or modify it under
       6  // the terms of the GNU General Public License as published by the Free
       7  // Software Foundation; either version 3, or (at your option) any later
       8  // version.
       9  
      10  // GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      11  // WARRANTY; without even the implied warranty of MERCHANTABILITY or
      12  // FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      13  // for more details.
      14  
      15  // You should have received a copy of the GNU General Public License
      16  // along with GCC; see the file COPYING3.  If not see
      17  // <http://www.gnu.org/licenses/>.
      18  
      19  #ifndef RUST_AST_FRAGMENT_H
      20  #define RUST_AST_FRAGMENT_H
      21  
      22  #include "rust-ast.h"
      23  #include "rust-system.h"
      24  
      25  namespace Rust {
      26  namespace AST {
      27  
      28  enum class FragmentKind
      29  {
      30    /**
      31     * A completely expanded AST Fragment. This signifies that all
      32     * `SingleASTNode`s in the `nodes` vector are valid.
      33     *
      34     * Note that this doesn't imply that the expansion is "done". One of the
      35     * expanded nodes could very well be another macro invocation
      36     */
      37    Complete,
      38    /**
      39     * An error fragment.
      40     */
      41    Error,
      42  };
      43  
      44  /**
      45   * An AST Fragment. Previously named `ASTFragment`.
      46   *
      47   * Basically, a "fragment" that can be incorporated into the AST, created as
      48   * a result of macro expansion. Really annoying to work with due to the fact
      49   * that macros can really expand to anything. As such, horrible representation
      50   * at the moment.
      51   */
      52  class Fragment
      53  {
      54  public:
      55    Fragment (Fragment const &other);
      56    Fragment &operator= (Fragment const &other);
      57  
      58    /**
      59     * Create an error fragment
      60     */
      61    static Fragment create_error ();
      62  
      63    /**
      64     * Create a complete AST fragment
      65     */
      66    Fragment (std::vector<AST::SingleASTNode> nodes,
      67  	    std::vector<std::unique_ptr<AST::Token>> tokens);
      68  
      69    /**
      70     * Create a complete AST fragment made of a single token
      71     */
      72    Fragment (std::vector<AST::SingleASTNode> nodes,
      73  	    std::unique_ptr<AST::Token> tok);
      74  
      75    FragmentKind get_kind () const;
      76    std::vector<SingleASTNode> &get_nodes ();
      77    std::vector<std::unique_ptr<AST::Token>> &get_tokens ();
      78  
      79    bool is_error () const;
      80    bool should_expand () const;
      81  
      82    bool is_expression_fragment () const;
      83    bool is_type_fragment () const;
      84  
      85    std::unique_ptr<Expr> take_expression_fragment ();
      86    std::unique_ptr<Type> take_type_fragment ();
      87  
      88    void accept_vis (ASTVisitor &vis);
      89  
      90  private:
      91    Fragment (FragmentKind kind, std::vector<SingleASTNode> nodes,
      92  	    std::vector<std::unique_ptr<AST::Token>> tokens);
      93  
      94    FragmentKind kind;
      95  
      96    /**
      97     * Basic idea: essentially, a vector of tagged unions of different AST node
      98     * types. Now, this could actually be stored without a tagged union if the
      99     * different AST node types had a unified parent, but that would create
     100     * issues with the diamond problem or significant performance penalties. So
     101     * a tagged union had to be used instead. A vector is used to represent the
     102     * ability for a macro to expand to two statements, for instance.
     103     */
     104    std::vector<SingleASTNode> nodes;
     105  
     106    /**
     107     * The tokens associated with an AST fragment. This vector represents the
     108     * actual tokens of the various nodes that are part of the fragment.
     109     */
     110    std::vector<std::unique_ptr<AST::Token>> tokens;
     111  
     112    /**
     113     * We need to make a special case for Expression and Type fragments as only
     114     * one Node will be extracted from the `nodes` vector
     115     */
     116    bool is_single_fragment () const;
     117    bool is_single_fragment_of_kind (SingleASTNode::NodeType expected) const;
     118    void assert_single_fragment (SingleASTNode::NodeType expected) const;
     119  };
     120  } // namespace AST
     121  } // namespace Rust
     122  
     123  #endif // !RUST_AST_FRAGMENT_H