ast.hpp

Go to the documentation of this file.

/*
 * Copyright 2023 Blue Brain Project, EPFL.
 * See the top-level LICENSE file for details.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
///
/// THIS FILE IS GENERATED AT BUILD TIME AND SHALL NOT BE EDITED.
///
 
#pragma once
 
/**
 * \dir
 * \brief Auto generated AST Implementations
 *
 * \file
 * \brief Auto generated AST classes declaration
 */
 
#include <string>
#include <vector>
#include <unordered_set>
 
#include "ast/ast_decl.hpp"
#include "ast/ast_common.hpp"
#include "lexer/modtoken.hpp"
#include "utils/common_utils.hpp"
#include "visitors/visitor.hpp"
 
namespace nmodl::ast {
 
/**
 * \defgroup ast_class AST Classes
 * \ingroup ast
 * \brief Classes for implementing Abstract Syntax Tree (AST)
 * \{
 */
 
/**
 * \brief Base class for all Abstract Syntax Tree node types
 *
 * Every node in the Abstract Syntax Tree is inherited from base class
 * ast::Ast. This class provides base properties and pure virtual
 * functions that must be implemented by base classes. We inherit from
 * std::enable_shared_from_this to get a `shared_ptr` from `this` pointer.
 *
 * \todo With the ast::Node as another top level node, this can be removed
 *       in the future.
 */
struct Ast: public std::enable_shared_from_this<Ast> {
  private:
  /**
   * \brief Generic pointer to the parent
   *
   * Children types can be known at compile time. Conversely, many parents
   * can have the same children type. Thus, this is just a pointer to
   * the base class. The pointer to the parent cannot have ownership
   * (circular ownership problem). weak_ptr you say? Yes, however weak_ptr
   * can be instantiated from shared_ptr (not this). Whys is this a problem?
   * In bison things must be passed around as raw pointers (because it uses
   * unions etc.) and there are cases where the shared_ptr to the parent
   * was not yet created while the child is added (throwing a bad_weak_ptr
   * exception).
   *
   * i.e. in bison the lines:
   *
   * ast::WatchStatement* a = new ast::WatchStatement();
   * yylhs.value.as< ast::WatchStatement* > ()->add_watch(a);
   *
   * would throw a bad_weak_ptr exception because when you call add_watch
   * the shared_ptr_from_this to "a" is not yet created.
   */
  Ast* parent = nullptr;
 
  public:
 
  /// \name Ctor & dtor
  /// \{
 
  Ast() = default;
 
  virtual ~Ast() = default;
 
  /// \}
 
 
  /// \name Pure Virtual Functions
  /// \{
 
  /**
   * \brief Return type (ast::AstNodeType) of AST node
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type is can be used to check/compare node types.
   */
  virtual AstNodeType get_node_type() const = 0;
 
  /**
   * \brief Return type (ast::AstNodeType) of ast node as std::string
   *
   * Every node in the ast has a type defined in ast::AstNodeType.
   * This type name can be returned as a std::string for printing
   * ast to text/json form.
   *
   * \return name of the node type as a string
   *
   * \sa Ast::get_node_name
   */
  virtual std::string get_node_type_name() const = 0;
 
  /**
   * \brief Return NMODL statement of ast node as std::string
   *
   * Every node is related to a special statement in the NMODL. This
   * statement can be returned as a std::string for printing to
   * text/json form.
   *
   * \return name of the statement as a string
   *
   * \sa Ast::get_nmodl_name
   */
  virtual std::string get_nmodl_name() const {
    throw std::runtime_error("get_nmodl_name not implemented");
  }
 
  /**
   * \brief Accept (or visit) the AST node using current visitor
   *
   * Instead of visiting children of AST node, like Ast::visit_children,
   * accept allows to visit the current node itself using the concrete
   * visitor provided.
   *
   * \param v Concrete visitor that will be used to recursively visit children
   *
   * \note Below is an example of `accept` method implementation which shows how
   *       visitor method corresponding to ast::IndexedName node is called allowing
   *       to visit the node itself in the visitor.
   *
   * \code{.cpp}
   *   void IndexedName::accept(visitor::Visitor& v) override {
   *       v.visit_indexed_name(this);
   *   }
   * \endcode
   *
   */
  virtual void accept(visitor::Visitor& v) = 0;
 
  /**
   * \brief Accept (or visit) the AST node using a given visitor
   * \param v constant visitor visiting the AST node
   * \ref accept(visitor::Visitor&);
   */
  virtual void accept(visitor::ConstVisitor& v) const = 0;
 
  /**
   * \brief Visit children i.e. member of AST node using provided visitor
   *
   * Different nodes in the AST have different members (i.e. children). This method
   * recursively visits children using provided concrete visitor.
   *
   * \param v Concrete visitor that will be used to recursively visit node
   *
   * \note Below is an example of `visit_children` method implementation which shows
   *       ast::IndexedName node children are visited instead of node itself.
   *
   * \code{.cpp}
   * void IndexedName::visit_children(visitor::Visitor& v) {
   *    name->accept(v);
   *    length->accept(v);
   * }
   * \endcode
   */
  virtual void visit_children(visitor::Visitor& v) = 0;
 
  /**
   * \copydoc visit_children(visitor::Visitor& v)
   */
  virtual void visit_children(visitor::ConstVisitor& v) const = 0;
 
  /**
   * \brief Create a copy of the current node
   *
   * Recursively make a new copy/clone of the current node including
   * all members and return a pointer to the node. This is used for
   * passes like nmodl::visitor::InlineVisitor where nodes are cloned in the
   * ast.
   *
   * \return pointer to the clone/copy of the current node
   */
  virtual Ast* clone() const;
 
  /// \}
 
  /// \name Not implemented
  /// \{
 
  /**
   * \brief Return name of of the node
   *
   * Some ast nodes have a member marked designated as node name. For example,
   * in case of ast::FunctionCall, name of the function is returned as a node
   * name. Note that this is different from ast node type name and not every
   * ast node has name.
   *
   * \return name of the node as std::string
   *
   * \sa Ast::get_node_type_name
   */
  virtual std::string get_node_name() const;
 
  /**
   * \brief Return associated token for the AST node
   *
   * Not all ast nodes have token information. For example, nmodl::visitor::NeuronSolveVisitor
   * can insert new nodes in the ast as a solution of ODEs. In this case, we return
   * nullptr to store in the nmodl::symtab::SymbolTable.
   *
   * \return pointer to token if exist otherwise nullptr
   */
  virtual const ModToken* get_token() const;
 
  /**
   * \brief Return associated symbol table for the AST node
   *
   * Certain ast nodes (e.g. inherited from ast::Block) have associated
   * symbol table. These nodes have nmodl::symtab::SymbolTable as member
   * and it can be accessed using this method.
   *
   * \return pointer to the symbol table
   *
   * \sa nmodl::symtab::SymbolTable nmodl::visitor::SymtabVisitor
   */
  virtual symtab::SymbolTable* get_symbol_table() const;
 
  /**
   * \brief Return associated statement block for the AST node
   *
   * Top level block nodes encloses all statements in the ast::StatementBlock.
   * For example, ast::BreakpointBlock has all statements in curly brace (`{ }`)
   * stored in ast::StatementBlock :
   *
   * \code
   *     BREAKPOINT {
   *         SOLVE states METHOD cnexp
   *         gNaTs2_t = gNaTs2_tbar*m*m*m*h
   *         ina = gNaTs2_t*(v-ena)
   *     }
   * \endcode
   *
   * This method return enclosing statement block.
   *
   * \return pointer to the statement block if exist
   *
   * \sa ast::StatementBlock
   */
  virtual std::shared_ptr<StatementBlock> get_statement_block() const;
 
  /**
   * \brief Set symbol table for the AST node
   *
   * Top level, block scoped nodes store symbol table in the ast node.
   * nmodl::visitor::SymtabVisitor then used this method to setup symbol table
   * for every node in the ast.
   *
   * \sa nmodl::visitor::SymtabVisitor
   */
  virtual void set_symbol_table(symtab::SymbolTable* symtab);
 
  /**
   * \brief Set name for the AST node
   *
   * Some ast nodes have a member marked designated as node name (e.g. nodes
   * derived from ast::Identifier). This method is used to set new name for those
   * nodes. This useful for passes like nmodl::visitor::RenameVisitor.
   *
   * \sa Ast::get_node_type_name Ast::get_node_name
   */
  virtual void set_name(const std::string& name);
 
  /**
   * \brief Negate the value of AST node
   *
   * Parser parse `-x` in two parts : `x` and then `-`. Once second token
   * `-` is encountered, the corresponding value of ast node needs to be
   * multiplied by `-1` for ast::Number node types or apply `!` operator
   for the nodes of type ast::Boolean.
   */
  virtual void negate();
  /// \}
 
  /// get std::shared_ptr from `this` pointer of the AST node
  virtual std::shared_ptr<Ast> get_shared_ptr();
 
  /// get std::shared_ptr from `this` pointer of the AST node
  virtual std::shared_ptr<const Ast> get_shared_ptr() const;
 
  /**
   *\brief Check if the ast node is an instance of ast::Ast
   * \return true if object of type ast::Ast
   */
  virtual bool is_ast() const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Node
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_node () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Statement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Expression
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_expression () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Block
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Identifier
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_identifier () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Number
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_number () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::String
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_string () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Integer
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_integer () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Float
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_float () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Double
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_double () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Boolean
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_boolean () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Name
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_name () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::PrimeName
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_prime_name () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::IndexedName
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_indexed_name () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::VarName
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_var_name () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Argument
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_argument () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ReactVarName
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_react_var_name () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ReadIonVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_read_ion_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::WriteIonVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_write_ion_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::NonspecificCurVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_nonspecific_cur_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ElectrodeCurVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_electrode_cur_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::RangeVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_range_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::GlobalVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_global_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::PointerVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_pointer_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::RandomVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_random_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BbcorePointerVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_bbcore_pointer_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ExternVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_extern_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ParamBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_param_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::IndependentBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_independent_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::AssignedBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_assigned_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::StateBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_state_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::InitialBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_initial_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ConstructorBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_constructor_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::DestructorBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_destructor_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::StatementBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_statement_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::DerivativeBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_derivative_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LinearBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_linear_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::NonLinearBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_non_linear_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::DiscreteBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_discrete_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::FunctionTableBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_function_table_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::FunctionBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_function_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ProcedureBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_procedure_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::NetReceiveBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_net_receive_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::SolveBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_solve_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BreakpointBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_breakpoint_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BeforeBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_before_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::AfterBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_after_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BABlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_ba_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ForNetcon
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_for_netcon () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::KineticBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_kinetic_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::UnitBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_unit_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ConstantBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_constant_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::NeuronBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_neuron_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Unit
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_unit () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::DoubleUnit
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_double_unit () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LocalVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_local_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Limits
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_limits () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::NumberRange
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_number_range () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ConstantVar
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_constant_var () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BinaryOperator
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_binary_operator () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::UnaryOperator
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_unary_operator () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ReactionOperator
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_reaction_operator () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ParenExpression
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_paren_expression () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BinaryExpression
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_binary_expression () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::DiffEqExpression
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_diff_eq_expression () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::UnaryExpression
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_unary_expression () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::NonLinEquation
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_non_lin_equation () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LinEquation
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_lin_equation () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::FunctionCall
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_function_call () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Watch
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_watch () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BABlockType
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_ba_block_type () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::UnitDef
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_unit_def () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::FactorDef
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_factor_def () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Valence
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_valence () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::UnitState
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_unit_state () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LocalListStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_local_list_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Model
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_model () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Define
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_define () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Include
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_include () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ParamAssign
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_param_assign () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::AssignedDefinition
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_assigned_definition () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ConductanceHint
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_conductance_hint () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ExpressionStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_expression_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ProtectStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_protect_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::FromStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_from_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::WhileStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_while_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::IfStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_if_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ElseIfStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_else_if_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ElseStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_else_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::WatchStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_watch_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::MutexLock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_mutex_lock () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::MutexUnlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_mutex_unlock () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Conserve
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_conserve () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Compartment
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_compartment () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LonDiffuse
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_lon_diffuse () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ReactionStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_reaction_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LagStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_lag_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ConstantStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_constant_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::TableStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_table_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Suffix
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_suffix () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Useion
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_useion () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Nonspecific
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_nonspecific () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ElectrodeCurrent
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_electrode_current () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Range
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_range () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Global
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_global () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::RandomVarList
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_random_var_list () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Pointer
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_pointer () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BbcorePointer
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_bbcore_pointer () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::External
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_external () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::ThreadSafe
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_thread_safe () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Verbatim
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_verbatim () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LineComment
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_line_comment () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::BlockComment
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_block_comment () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::OntologyStatement
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_ontology_statement () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::Program
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_program () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::NrnStateBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_nrn_state_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::EigenNewtonSolverBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_eigen_newton_solver_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::EigenLinearSolverBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_eigen_linear_solver_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::CvodeBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_cvode_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::LongitudinalDiffusionBlock
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_longitudinal_diffusion_block () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::WrappedExpression
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_wrapped_expression () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::DerivimplicitCallback
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_derivimplicit_callback () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::SolutionExpression
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_solution_expression () const noexcept;
 
  /**
   * \brief Check if the ast node is an instance of ast::UpdateDt
   * \return true if object of type ast::OntologyStatement
   */
  virtual bool is_update_dt () const noexcept;
 
 
  /**
   *\brief Parent getter
   *
   * returning a raw pointer may create less problems that the
   * shared_from_this from the parent.
   *
   * Check \ref Ast::parent for more information
   */
  virtual Ast* get_parent() const;
 
  /**
   *\brief Parent setter
   *
   * Usually, the parent pointer cannot be set in the constructor
   * because children are generally build BEFORE the parent. Conversely,
   * we set children parents directly in the parent constructor using
   * set_parent_in_children()
   *
   *  Check \ref Ast::parent for more information
   */
  virtual void set_parent(Ast* p);
};
 
}  // namespace nmodl::ast